Qe Code Intelligence

Name: Qe Code Intelligence
Author: proffesor-for-testing

proffesor-for-testing/agentic-qe

40 installs
433 repo stars
Updated August 4, 2026
proffesor-for-testing/agentic-qe

qe code intelligence is a Claude Code skill for ai & agent building.

About

qe code intelligence is a Claude Code skill for ai & agent building. It helps solo builders move faster with AI-assisted development.

qe code intelligence
AI & Agent Building
AI-coding skill

Qe Code Intelligence by the numbers

40 all-time installs (skills.sh)
Ranked #8,266 of 16,546 AI & Agent Building skills by installs in the Skillselion catalog
Data as of Aug 5, 2026 (Skillselion catalog sync)

npx skills add https://github.com/proffesor-for-testing/agentic-qe --skill qe-code-intelligence

Add your badge

Show developers this skill is listed on Skillselion. Paste this into your README.

[![Listed on Skillselion](https://skillselion.com/badge/skills/proffesor-for-testing/agentic-qe/qe-code-intelligence.svg)](https://skillselion.com/skills/proffesor-for-testing/agentic-qe/qe-code-intelligence)

Installs	40
repo stars	★ 433
Last updated	August 4, 2026
Repository	proffesor-for-testing/agentic-qe ↗

How do I helps with ai & agent building tasks.?

Helps with ai & agent building tasks.

Who is it for?

Best when you're working on ai & agent building and need structured help with qe code intelligence.

Skip if: Teams with no ai & agent building needs, or anyone wanting a generic chat assistant without this specific workflow.

When should I use this skill?

When you need to helps with ai & agent building tasks., or when qe code intelligence is a claude code skill for ai & agent building.

What you get

Structured output aligned to qe code intelligence: qe code intelligence, AI & Agent Building.

Files

SKILL.mdMarkdownGitHub ↗

QE Code Intelligence

Purpose

Guide the use of v3's code intelligence capabilities including knowledge graph construction, semantic code search, dependency mapping, and context-aware code understanding with significant token reduction.

Activation

When understanding unfamiliar code
When searching for code semantically
When analyzing dependencies
When building code knowledge graphs
When reducing context for AI operations

Quick Start

# Index codebase into knowledge graph
aqe code index src/ --incremental

# Semantic code search
aqe code search "authentication middleware"

# Analyze change impact
aqe code impact src/services/UserService.ts --depth 3

# Map dependencies
aqe code deps src/

# Analyze complexity and find hotspots
aqe code complexity src/

Agent Workflow

// Build knowledge graph
Task("Index codebase", `
  Build knowledge graph for the project:
  - Parse all TypeScript files in src/
  - Extract entities (classes, functions, types)
  - Map relationships (imports, calls, inheritance)
  - Generate embeddings for semantic search
  Store in AgentDB vector database.
`, "qe-kg-builder")

// Semantic search
Task("Find relevant code", `
  Search for code related to "user authentication flow":
  - Use semantic similarity (not just keyword)
  - Include related functions and types
  - Rank by relevance score
  - Return with minimal context (80% token reduction)
`, "qe-code-intelligence")

Knowledge Graph Operations

1. Codebase Indexing

await knowledgeGraph.index({
  source: 'src/**/*.ts',
  extraction: {
    entities: ['class', 'function', 'interface', 'type', 'variable'],
    relationships: ['imports', 'calls', 'extends', 'implements', 'uses'],
    metadata: ['jsdoc', 'complexity', 'lines']
  },
  embeddings: {
    model: 'code-embedding',
    dimensions: 384,
    normalize: true
  },
  incremental: true  // Only index changed files
});

2. Semantic Search

await semanticSearcher.search({
  query: 'payment processing with stripe',
  options: {
    similarity: 'cosine',
    threshold: 0.7,
    limit: 20,
    includeContext: true
  },
  filters: {
    fileTypes: ['.ts', '.tsx'],
    excludePaths: ['node_modules', 'dist']
  }
});

3. Dependency Analysis

await dependencyMapper.analyze({
  entry: 'src/services/OrderService.ts',
  depth: 3,
  direction: 'both',  // imports and importedBy
  output: {
    graph: true,
    metrics: {
      afferentCoupling: true,
      efferentCoupling: true,
      instability: true
    }
  }
});

Token Reduction Strategy

// Get context with 80% token reduction
const context = await codeIntelligence.getOptimizedContext({
  query: 'implement user registration',
  budget: 4000,  // max tokens
  strategy: {
    relevanceRanking: true,
    summarization: true,
    codeCompression: true,
    deduplication: true
  },
  include: {
    signatures: true,
    implementations: 'relevant-only',
    comments: 'essential',
    examples: 'top-3'
  }
});

Knowledge Graph Schema

interface KnowledgeGraph {
  entities: {
    id: string;
    type: 'class' | 'function' | 'interface' | 'type' | 'file';
    name: string;
    file: string;
    line: number;
    embedding: number[];
    metadata: Record<string, any>;
  }[];
  relationships: {
    source: string;
    target: string;
    type: 'imports' | 'calls' | 'extends' | 'implements' | 'uses';
    weight: number;
  }[];
  indexes: {
    byName: Map<string, string[]>;
    byFile: Map<string, string[]>;
    byType: Map<string, string[]>;
  };
}

Search Results

interface SearchResult {
  entity: {
    name: string;
    type: string;
    file: string;
    line: number;
  };
  relevance: number;
  snippet: string;
  context: {
    before: string[];
    after: string[];
    related: string[];
  };
  explanation: string;
}

CLI Examples

# Full reindex
aqe code index src/

# Incremental index (changed files only)
aqe code index src/ --incremental

# Index only files changed since a git ref
aqe code index . --git-since HEAD~5

# Semantic code search
aqe code search "database connection"

# Change impact analysis
aqe code impact src/services/UserService.ts

# Dependency mapping
aqe code deps src/ --depth 5

# Complexity metrics and hotspots
aqe code complexity src/ --format json

Gotchas

WARNING: code-intelligence domain has 18% success rate — prefer direct grep/glob over agent-based code search for simple queries
Knowledge graph construction fails on repos >50K LOC — scope to specific modules
Semantic search returns irrelevant results without domain-specific embeddings — always verify search results manually
Agent claims "80% token reduction" but may skip critical context — verify key files are included in results
Fleet must be initialized before using: run aqe health to diagnose, or aqe init to re-initialize if you get initialization errors

Coordination

Primary Agents: qe-kg-builder, qe-dependency-mapper, qe-impact-analyzer, qe-code-complexity Coordinator: qe-code-intelligence Related Skills: qe-test-generation, qe-defect-intelligence

# =============================================================================
# AQE Skill Evaluation Test Suite: QE Code Intelligence v1.0.0
# =============================================================================
#
# Comprehensive evaluation suite for the qe-code-intelligence skill.
# Tests knowledge graph construction, semantic code search, dependency mapping,
# and intelligent context retrieval with 80% token reduction.
#
# Schema: .claude/skills/.validation/schemas/skill-eval.schema.json
# Validator: .claude/skills/qe-code-intelligence/scripts/validate-config.json
#
# Coverage:
# - Codebase indexing and knowledge graph construction
# - Semantic search with relevance ranking
# - Dependency analysis and mapping
# - Intelligent context retrieval with token optimization
# - Entity relationship extraction
#
# =============================================================================

skill: qe-code-intelligence
version: 1.0.0
description: >
  Comprehensive evaluation suite for the qe-code-intelligence skill.
  Tests knowledge graph construction, semantic code search, dependency mapping,
  context-aware code understanding, and intelligent token budget optimization.

# =============================================================================
# Multi-Model Configuration
# =============================================================================

models_to_test:
  - claude-sonnet-4-6    # Primary (high accuracy expected)
  - claude-haiku-4-5     # Fast model (minimum quality floor)

# =============================================================================
# MCP Integration Configuration
# =============================================================================

mcp_integration:
  enabled: true
  namespace: skill-validation

  query_patterns: true
  track_outcomes: true
  store_patterns: true
  share_learning: true
  update_quality_gate: true

  target_agents:
    - qe-learning-coordinator
    - qe-queen-coordinator
    - qe-code-intelligence
    - qe-kg-builder

# =============================================================================
# ReasoningBank Learning Configuration
# =============================================================================

learning:
  store_success_patterns: true
  store_failure_patterns: true
  pattern_ttl_days: 90
  min_confidence_to_store: 0.7
  cross_model_comparison: true

# =============================================================================
# Result Format Configuration
# =============================================================================

result_format:
  json_output: true
  markdown_report: true
  include_raw_output: false
  include_timing: true
  include_token_usage: true

# =============================================================================
# Environment Setup
# =============================================================================

setup:
  required_tools:
    - jq
  environment_variables:
    KG_CACHE_ENABLED: "true"
    SEARCH_LIMIT: "20"
  fixtures: []

# =============================================================================
# TEST CASES
# =============================================================================

test_cases:
  # ---------------------------------------------------------------------------
  # CATEGORY: Knowledge Graph Construction
  # ---------------------------------------------------------------------------

  - id: tc001_kg_codebase_indexing
    description: "Build knowledge graph from TypeScript codebase with entity extraction"
    category: knowledge_graph
    priority: critical

    input:
      prompt: |
        Index a TypeScript codebase with the following structure:
        - Extract all classes, interfaces, functions, and types
        - Map relationships: imports, calls, inheritance, implementation
        - Generate embeddings for semantic search
        - Support incremental indexing for changed files only

        What entities and relationships should be extracted?
      context:
        language: typescript
        scope: src/
        incremental: true

    expected_output:
      must_contain:
        - "entities"
        - "classes"
        - "functions"
        - "relationships"
        - "imports"
        - "embeddings"
      must_not_contain:
        - "error"
        - "cannot parse"
      severity_classification: critical
      finding_count:
        min: 1

    validation:
      schema_check: true
      keyword_match_threshold: 0.8
      reasoning_quality_min: 0.75

  - id: tc002_entity_relationship_mapping
    description: "Extract and validate entity-relationship metadata from code"
    category: knowledge_graph
    priority: high

    input:
      prompt: |
        For this UserService class, extract:
        1. Class metadata (name, file, line, complexity)
        2. Method signatures
        3. Dependencies (what it imports)
        4. Relationships (what imports it)

        ```typescript
        export class UserService {
          constructor(private db: Database) {}
          async getUserById(id: string): Promise<User> { ... }
        }
        ```
      context:
        file: src/services/UserService.ts
        extract_complexity: true

    expected_output:
      must_contain:
        - "UserService"
        - "Database"
        - "complexity"
        - "dependencies"
        - "methods"
      must_not_contain:
        - "parse error"
      severity_classification: high

    validation:
      schema_check: true
      keyword_match_threshold: 0.75

  # ---------------------------------------------------------------------------
  # CATEGORY: Semantic Code Search
  # ---------------------------------------------------------------------------

  - id: tc003_semantic_search_relevance
    description: "Search code semantically and rank results by relevance"
    category: semantic_search
    priority: critical

    input:
      prompt: |
        Perform semantic search in a codebase for "payment processing with stripe".
        Return top 10 results ranked by relevance score (0-1).

        Results should include:
        - File location and line number
        - Code snippet
        - Relevance explanation

        How would you score relevance?
      context:
        query: "payment processing with stripe"
        limit: 10
        threshold: 0.7

    expected_output:
      must_contain:
        - "relevance"
        - "score"
        - "ranking"
        - "snippet"
        - "payment"
        - "stripe"
      must_not_contain:
        - "keyword matching"
      severity_classification: critical

    validation:
      schema_check: true
      keyword_match_threshold: 0.8
      reasoning_quality_min: 0.75

  - id: tc004_search_with_context_retrieval
    description: "Return semantic search results with intelligent context"
    category: semantic_search
    priority: high

    input:
      prompt: |
        Search for "authentication middleware" and return results with:
        - Before/after code context (surrounding lines)
        - Related entities (what it calls, what calls it)
        - Usage examples if available

        How would you prioritize context when token budget is limited?
      context:
        query: "authentication middleware"
        include_context: true
        max_tokens: 2000

    expected_output:
      must_contain:
        - "authentication"
        - "middleware"
        - "context"
        - "related"
        - "usage"
      finding_count:
        min: 1

    validation:
      schema_check: true
      keyword_match_threshold: 0.75

  # ---------------------------------------------------------------------------
  # CATEGORY: Dependency Analysis
  # ---------------------------------------------------------------------------

  - id: tc005_dependency_mapping
    description: "Map dependencies for a service with depth analysis"
    category: dependencies
    priority: critical

    input:
      prompt: |
        Analyze dependencies for OrderService at depth 3:
        - Direct dependencies (1 level)
        - Transitive dependencies (2 levels)
        - Deep dependencies (3 levels)

        Calculate coupling metrics:
        - Afferent coupling (incoming dependencies)
        - Efferent coupling (outgoing dependencies)
        - Instability score
      context:
        entry_point: src/services/OrderService.ts
        depth: 3
        direction: both

    expected_output:
      must_contain:
        - "dependencies"
        - "coupling"
        - "afferent"
        - "efferent"
        - "instability"
      must_not_contain:
        - "unable"
        - "cannot resolve"
      severity_classification: critical

    validation:
      schema_check: true
      keyword_match_threshold: 0.8

  - id: tc006_circular_dependency_detection
    description: "Detect circular dependencies that could cause issues"
    category: dependencies
    priority: high

    input:
      prompt: |
        How would you detect circular dependencies in a codebase?
        A -> B -> C -> A

        What are the implications of circular dependencies?
        How would you report and fix them?
      context:
        analysis_type: circular_detection
        fix_suggestions: true

    expected_output:
      must_contain:
        - "circular"
        - "dependencies"
        - "cycle"
        - "implications"
        - "fix"
      severity_classification: high

    validation:
      schema_check: true
      keyword_match_threshold: 0.75

  # ---------------------------------------------------------------------------
  # CATEGORY: Token Optimization
  # ---------------------------------------------------------------------------

  - id: tc007_intelligent_context_optimization
    description: "Retrieve context with 80% token reduction"
    category: optimization
    priority: critical

    input:
      prompt: |
        Retrieve context for "implement user registration" with:
        - Token budget: 4000 tokens
        - Include function signatures
        - Include relevant examples (top 3)
        - Summarize implementations when necessary
        - Deduplicate related code

        Achieve 80% token reduction compared to full context.
        How would you measure the reduction?
      context:
        query: "implement user registration"
        budget_tokens: 4000
        target_reduction: 0.8

    expected_output:
      must_contain:
        - "token"
        - "optimization"
        - "budget"
        - "signature"
        - "example"
        - "reduction"
      must_not_contain:
        - "full context"
      severity_classification: critical

    validation:
      schema_check: true
      keyword_match_threshold: 0.8
      reasoning_quality_min: 0.75

  - id: tc008_context_prioritization
    description: "Prioritize context elements by relevance and importance"
    category: optimization
    priority: high

    input:
      prompt: |
        When token budget is limited (2000 tokens), what would you prioritize?

        1. Function signatures (essential)
        2. Comments/documentation (helpful)
        3. Full implementations (verbose)
        4. Examples (useful)
        5. Related entities (context)

        How would you rank these for maximum usefulness?
      context:
        budget_tokens: 2000
        prioritization: true

    expected_output:
      must_contain:
        - "prioritize"
        - "signatures"
        - "relevant"
        - "essential"
        - "examples"
      finding_count:
        min: 1

    validation:
      schema_check: true
      keyword_match_threshold: 0.75

  # ---------------------------------------------------------------------------
  # CATEGORY: Negative Tests
  # ---------------------------------------------------------------------------

  - id: tc009_graceful_handling_missing_code
    description: "Handle missing or unparseable code gracefully"
    category: negative
    priority: high

    input:
      prompt: |
        How should the knowledge graph handle:
        1. Files with syntax errors
        2. Generated code (node_modules, dist/)
        3. Non-supported languages
        4. Binary files
        5. Empty files

        What error recovery strategies would you use?
      context:
        include_error_handling: true
        exclude_patterns: ["node_modules", "dist", "*.min.js"]

    expected_output:
      must_contain:
        - "graceful"
        - "error"
        - "handle"
        - "skip"
        - "recovery"
      must_not_contain:
        - "crash"
        - "fail"
      finding_count:
        max: 2

    validation:
      schema_check: true
      allow_partial: true

# =============================================================================
# SUCCESS CRITERIA
# =============================================================================

success_criteria:
  pass_rate: 0.8
  critical_pass_rate: 1.0
  avg_reasoning_quality: 0.75
  max_execution_time_ms: 300000
  cross_model_variance: 0.15

# =============================================================================
# METADATA
# =============================================================================

metadata:
  author: "qe-code-intelligence"
  created: "2026-02-02"
  last_updated: "2026-02-02"
  coverage_target: >
    Knowledge graph construction with entity/relationship extraction, semantic
    code search with relevance ranking, dependency analysis with coupling metrics,
    circular dependency detection, and intelligent token budget optimization
    achieving 80% token reduction.

{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "$id": "https://agentic-qe.dev/schemas/skills/qe-code-intelligence/output.json",
  "title": "QE Code Intelligence Skill Output Schema",
  "description": "Schema for qe-code-intelligence skill output with code graph, dependencies, and complexity metrics.",
  "type": "object",
  "required": ["skillName", "version", "timestamp", "status", "trustTier", "output"],
  "properties": {
    "skillName": {
      "type": "string",
      "const": "qe-code-intelligence"
    },
    "version": {
      "type": "string",
      "pattern": "^\\d+\\.\\d+\\.\\d+(-[a-zA-Z0-9]+)?$"
    },
    "timestamp": {
      "type": "string"
    },
    "status": {
      "type": "string",
      "enum": ["success", "partial", "failed", "skipped"]
    },
    "trustTier": {
      "type": "integer",
      "const": 3
    },
    "output": {
      "type": "object",
      "required": ["summary", "codeGraph", "complexityMetrics"],
      "properties": {
        "summary": {
          "type": "string",
          "minLength": 50,
          "maxLength": 2000,
          "description": "Human-readable summary of code intelligence analysis"
        },
        "codeGraph": {
          "$ref": "#/$defs/codeGraph",
          "description": "Code dependency and call graph structure"
        },
        "dependencies": {
          "type": "array",
          "items": {
            "$ref": "#/$defs/dependency"
          },
          "maxItems": 500,
          "description": "Module and package dependencies"
        },
        "complexityMetrics": {
          "$ref": "#/$defs/complexityMetrics",
          "description": "Code complexity measurements"
        },
        "qualityScore": {
          "$ref": "#/$defs/qualityScore",
          "description": "Overall code quality score"
        },
        "findings": {
          "type": "array",
          "items": {
            "$ref": "#/$defs/finding"
          },
          "maxItems": 200
        },
        "recommendations": {
          "type": "array",
          "items": {
            "$ref": "#/$defs/recommendation"
          },
          "maxItems": 50
        },
        "hotspots": {
          "type": "array",
          "items": {
            "$ref": "#/$defs/hotspot"
          },
          "maxItems": 50
        }
      }
    },
    "metadata": {
      "type": "object",
      "properties": {
        "executionTimeMs": { "type": "integer", "minimum": 0 },
        "toolsUsed": { "type": "array", "items": { "type": "string" } },
        "agentId": { "type": "string" },
        "analyzedFiles": { "type": "integer", "minimum": 0 },
        "analyzedLines": { "type": "integer", "minimum": 0 }
      }
    },
    "validation": {
      "type": "object",
      "properties": {
        "schemaValid": { "type": "boolean" },
        "contentValid": { "type": "boolean" },
        "confidence": { "type": "number", "minimum": 0, "maximum": 1 }
      }
    },
    "learning": {
      "type": "object",
      "properties": {
        "patternsDetected": { "type": "array", "items": { "type": "string" } },
        "reward": { "type": "number", "minimum": 0, "maximum": 1 }
      }
    }
  },
  "$defs": {
    "codeGraph": {
      "type": "object",
      "required": ["nodes", "edges"],
      "properties": {
        "nodes": {
          "type": "array",
          "items": {
            "$ref": "#/$defs/graphNode"
          },
          "description": "Code units (modules, classes, functions)"
        },
        "edges": {
          "type": "array",
          "items": {
            "$ref": "#/$defs/graphEdge"
          },
          "description": "Dependencies and call relationships"
        },
        "clusters": {
          "type": "array",
          "items": {
            "$ref": "#/$defs/cluster"
          },
          "description": "Identified code clusters/modules"
        },
        "entryPoints": {
          "type": "array",
          "items": { "type": "string" },
          "description": "Application entry points"
        },
        "circularDependencies": {
          "type": "array",
          "items": {
            "type": "array",
            "items": { "type": "string" }
          },
          "description": "Detected circular dependency cycles"
        }
      }
    },
    "graphNode": {
      "type": "object",
      "required": ["id", "name", "type"],
      "properties": {
        "id": { "type": "string" },
        "name": { "type": "string" },
        "type": { "type": "string", "enum": ["module", "class", "function", "method", "file", "package"] },
        "path": { "type": "string" },
        "lines": { "type": "integer", "minimum": 0 },
        "complexity": { "type": "number", "minimum": 0 },
        "coupling": { "type": "number", "minimum": 0 },
        "cohesion": { "type": "number", "minimum": 0, "maximum": 1 }
      }
    },
    "graphEdge": {
      "type": "object",
      "required": ["source", "target", "type"],
      "properties": {
        "source": { "type": "string" },
        "target": { "type": "string" },
        "type": { "type": "string", "enum": ["imports", "calls", "extends", "implements", "uses", "depends"] },
        "weight": { "type": "number", "minimum": 0 }
      }
    },
    "cluster": {
      "type": "object",
      "required": ["id", "name", "nodes"],
      "properties": {
        "id": { "type": "string" },
        "name": { "type": "string" },
        "nodes": { "type": "array", "items": { "type": "string" } },
        "cohesion": { "type": "number", "minimum": 0, "maximum": 1 },
        "coupling": { "type": "number", "minimum": 0 }
      }
    },
    "dependency": {
      "type": "object",
      "required": ["name", "type"],
      "properties": {
        "name": { "type": "string" },
        "type": { "type": "string", "enum": ["runtime", "devDependency", "peerDependency", "optional", "internal"] },
        "version": { "type": "string" },
        "versionConstraint": { "type": "string" },
        "usedBy": { "type": "array", "items": { "type": "string" } },
        "transitiveCount": { "type": "integer", "minimum": 0 },
        "vulnerabilities": {
          "type": "array",
          "items": {
            "type": "object",
            "properties": {
              "id": { "type": "string" },
              "severity": { "type": "string" },
              "fixedIn": { "type": "string" }
            }
          }
        },
        "outdated": { "type": "boolean" },
        "latestVersion": { "type": "string" }
      }
    },
    "complexityMetrics": {
      "type": "object",
      "properties": {
        "cyclomaticComplexity": {
          "type": "object",
          "properties": {
            "total": { "type": "number", "minimum": 0 },
            "average": { "type": "number", "minimum": 0 },
            "max": { "type": "number", "minimum": 0 },
            "maxLocation": { "type": "string" }
          }
        },
        "cognitiveComplexity": {
          "type": "object",
          "properties": {
            "total": { "type": "number", "minimum": 0 },
            "average": { "type": "number", "minimum": 0 },
            "max": { "type": "number", "minimum": 0 }
          }
        },
        "halsteadMetrics": {
          "type": "object",
          "properties": {
            "volume": { "type": "number" },
            "difficulty": { "type": "number" },
            "effort": { "type": "number" },
            "vocabulary": { "type": "integer" }
          }
        },
        "maintainabilityIndex": {
          "type": "number",
          "minimum": 0,
          "maximum": 100
        },
        "linesOfCode": {
          "type": "object",
          "properties": {
            "total": { "type": "integer", "minimum": 0 },
            "source": { "type": "integer", "minimum": 0 },
            "comment": { "type": "integer", "minimum": 0 },
            "blank": { "type": "integer", "minimum": 0 }
          }
        },
        "duplication": {
          "type": "object",
          "properties": {
            "percentage": { "type": "number", "minimum": 0, "maximum": 100 },
            "blocks": { "type": "integer", "minimum": 0 },
            "lines": { "type": "integer", "minimum": 0 }
          }
        }
      }
    },
    "qualityScore": {
      "type": "object",
      "required": ["value", "max"],
      "properties": {
        "value": { "type": "number", "minimum": 0, "maximum": 100 },
        "max": { "type": "number", "const": 100 },
        "grade": { "type": "string", "pattern": "^[A-F][+-]?$" },
        "trend": { "type": "string", "enum": ["improving", "stable", "declining", "unknown"] }
      }
    },
    "finding": {
      "type": "object",
      "required": ["id", "title", "severity"],
      "properties": {
        "id": { "type": "string", "pattern": "^CODE-\\d{3,6}$" },
        "title": { "type": "string", "minLength": 5, "maxLength": 200 },
        "description": { "type": "string", "maxLength": 2000 },
        "severity": { "type": "string", "enum": ["critical", "high", "medium", "low", "info"] },
        "category": { "type": "string", "enum": ["complexity", "coupling", "duplication", "dependency", "maintainability", "architecture"] },
        "location": {
          "type": "object",
          "properties": {
            "file": { "type": "string" },
            "line": { "type": "integer" },
            "column": { "type": "integer" }
          }
        },
        "remediation": { "type": "string", "maxLength": 2000 }
      }
    },
    "recommendation": {
      "type": "object",
      "required": ["id", "title", "priority"],
      "properties": {
        "id": { "type": "string", "pattern": "^REC-\\d{3,6}$" },
        "title": { "type": "string", "maxLength": 200 },
        "description": { "type": "string", "maxLength": 2000 },
        "priority": { "type": "string", "enum": ["critical", "high", "medium", "low"] },
        "effort": { "type": "string", "enum": ["trivial", "low", "medium", "high", "major"] },
        "impact": { "type": "string", "enum": ["complexity", "maintainability", "testability", "performance"] }
      }
    },
    "hotspot": {
      "type": "object",
      "required": ["path", "type"],
      "properties": {
        "path": { "type": "string" },
        "type": { "type": "string", "enum": ["complexity", "churn", "coupling", "bug-prone"] },
        "score": { "type": "number", "minimum": 0 },
        "changeFrequency": { "type": "integer", "minimum": 0 },
        "bugCount": { "type": "integer", "minimum": 0 }
      }
    }
  }
}

{
  "skillName": "qe-code-intelligence",
  "skillVersion": "1.0.0",
  "requiredTools": [
    "jq"
  ],
  "optionalTools": [
    "node",
    "python3"
  ],
  "schemaPath": "schemas/output.json",
  "requiredFields": [
    "skillName",
    "status",
    "output",
    "output.summary",
    "output.codeGraph",
    "output.complexityMetrics"
  ],
  "requiredNonEmptyFields": [
    "output.summary"
  ],
  "mustContainTerms": [
    "code",
    "complexity",
    "dependency"
  ],
  "mustNotContainTerms": [
    "TODO",
    "FIXME",
    "placeholder"
  ],
  "enumValidations": {
    ".status": [
      "success",
      "partial",
      "failed",
      "skipped"
    ]
  }
}