agentic-qe 3.8.6 → 3.8.8

package/dist/mcp/handlers/hypergraph-handler.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Agentic QE v3 - Hypergraph Query MCP Handler
+ *
+ * Exposes hypergraph queries as an MCP tool:
+ *   - stats: node/edge counts
+ *   - untested: functions without test coverage
+ *   - impacted: tests impacted by changed files
+ *   - gaps: functions with low coverage
+ */
+import type { ToolResult } from '../types.js';
+export interface HypergraphQueryParams {
+    /** Query type */
+    query: 'stats' | 'untested' | 'impacted' | 'gaps';
+    /** Changed files (for 'impacted' query) */
+    files?: string[];
+    /** Max coverage threshold (for 'gaps' query, default 50) */
+    maxCoverage?: number;
+    /** Max results (default 20) */
+    limit?: number;
+}
+export interface HypergraphQueryResult {
+    query: string;
+    data: Record<string, unknown>;
+    totalResults: number;
+}
+export declare function handleHypergraphQuery(params: HypergraphQueryParams): Promise<ToolResult<HypergraphQueryResult>>;
+//# sourceMappingURL=hypergraph-handler.d.ts.map

package/dist/mcp/handlers/hypergraph-handler.js

@@ -0,0 +1,140 @@
+/**
+ * Agentic QE v3 - Hypergraph Query MCP Handler
+ *
+ * Exposes hypergraph queries as an MCP tool:
+ *   - stats: node/edge counts
+ *   - untested: functions without test coverage
+ *   - impacted: tests impacted by changed files
+ *   - gaps: functions with low coverage
+ */
+import { join, resolve } from 'path';
+import { existsSync } from 'fs';
+import { v4 as uuidv4 } from 'uuid';
+import { findProjectRoot } from '../../kernel/unified-memory.js';
+import { openDatabase } from '../../shared/safe-db.js';
+import { createHypergraphEngine } from '../../integrations/ruvector/hypergraph-engine.js';
+import { toErrorMessage } from '../../shared/error-utils.js';
+// ============================================================================
+// Helpers
+// ============================================================================
+function makeResult(success, startTime, data, error) {
+    return {
+        success,
+        data,
+        error,
+        metadata: {
+            executionTime: Date.now() - startTime,
+            timestamp: new Date().toISOString(),
+            requestId: uuidv4(),
+            domain: 'code-intelligence',
+            toolName: 'hypergraph_query',
+            dataSource: 'real',
+        },
+    };
+}
+// ============================================================================
+// Handler
+// ============================================================================
+export async function handleHypergraphQuery(params) {
+    const startTime = Date.now();
+    try {
+        const projectRoot = findProjectRoot();
+        const dbPath = join(projectRoot, '.agentic-qe', 'memory.db');
+        if (!existsSync(dbPath)) {
+            return makeResult(false, startTime, undefined, `Database not found: ${dbPath}. Run "aqe init --auto" first.`);
+        }
+        const db = openDatabase(dbPath);
+        try {
+            const engine = await createHypergraphEngine({
+                db,
+                maxTraversalDepth: 10,
+                maxQueryResults: 1000,
+                enableVectorSearch: false,
+            });
+            const limit = params.limit || 20;
+            switch (params.query) {
+                case 'stats': {
+                    const stats = await engine.getStats();
+                    return makeResult(true, startTime, {
+                        query: 'stats',
+                        data: {
+                            totalNodes: stats.totalNodes,
+                            totalEdges: stats.totalEdges,
+                            nodesByType: stats.nodesByType,
+                            edgesByType: stats.edgesByType,
+                            avgComplexity: stats.avgComplexity,
+                            avgCoverage: stats.avgCoverage,
+                            nodesWithEmbeddings: stats.nodesWithEmbeddings,
+                        },
+                        totalResults: stats.totalNodes + stats.totalEdges,
+                    });
+                }
+                case 'untested': {
+                    const untested = await engine.findUntestedFunctions();
+                    const results = untested.slice(0, limit);
+                    return makeResult(true, startTime, {
+                        query: 'untested',
+                        data: {
+                            functions: results.map(fn => ({
+                                name: fn.name,
+                                filePath: fn.filePath,
+                                lineStart: fn.lineStart,
+                                complexity: fn.complexity,
+                            })),
+                        },
+                        totalResults: untested.length,
+                    });
+                }
+                case 'impacted': {
+                    if (!params.files || params.files.length === 0) {
+                        return makeResult(false, startTime, undefined, 'The "files" parameter is required for the "impacted" query.');
+                    }
+                    // Resolve relative paths to absolute so they match hypergraph entries
+                    const absoluteFiles = params.files.map(f => resolve(f));
+                    const tests = await engine.findImpactedTests(absoluteFiles);
+                    return makeResult(true, startTime, {
+                        query: 'impacted',
+                        data: {
+                            changedFiles: params.files,
+                            impactedTests: tests.map(t => ({
+                                name: t.name,
+                                filePath: t.filePath,
+                            })),
+                        },
+                        totalResults: tests.length,
+                    });
+                }
+                case 'gaps': {
+                    const maxCov = params.maxCoverage ?? 50;
+                    const gaps = await engine.findCoverageGaps(maxCov);
+                    const results = gaps.slice(0, limit);
+                    return makeResult(true, startTime, {
+                        query: 'gaps',
+                        data: {
+                            maxCoverage: maxCov,
+                            functions: results.map(fn => ({
+                                name: fn.name,
+                                filePath: fn.filePath,
+                                coverage: fn.coverage,
+                                complexity: fn.complexity,
+                            })),
+                        },
+                        totalResults: gaps.length,
+                    });
+                }
+                default:
+                    return makeResult(false, startTime, undefined, `Unknown query type: "${params.query}". Use: stats, untested, impacted, gaps`);
+            }
+        }
+        finally {
+            try {
+                db.close();
+            }
+            catch { /* ignore */ }
+        }
+    }
+    catch (error) {
+        return makeResult(false, startTime, undefined, toErrorMessage(error));
+    }
+}
+//# sourceMappingURL=hypergraph-handler.js.map

package/dist/mcp/handlers/index.d.ts

@@ -11,5 +11,6 @@ export { handleTeamList, handleTeamHealth, handleTeamMessage, handleTeamBroadcas
 export { handleMemoryStore, handleMemoryRetrieve, handleMemoryQuery, handleMemoryDelete, handleMemoryUsage, handleMemoryShare, } from './memory-handlers';
 export { handlePipelineLoad, handlePipelineRun, handlePipelineList, handlePipelineValidate, getPipelineRegistry, getPipelineLoader, type PipelineLoadParams, type PipelineLoadResult, type PipelineRunParams, type PipelineRunResult, type PipelineListParams, type PipelineListResult, type PipelineValidateParams, type PipelineValidateResult, } from './pipeline-handlers.js';
 export { handleValidationPipeline, type ValidationPipelineParams, type ValidationPipelineResult, } from './validation-pipeline-handler.js';
+export { handleHypergraphQuery, type HypergraphQueryParams, type HypergraphQueryResult, } from './hypergraph-handler.js';
 export { handleCrossPhaseStore, handleCrossPhaseQuery, handleAgentComplete, handlePhaseStart, handlePhaseEnd, handleCrossPhaseStats, handleFormatSignals, handleCrossPhaseCleanup, resetCrossPhaseHandlers, type StoreSignalParams, type StoreSignalResult, type QuerySignalsParams, type QuerySignalsResult, type AgentCompleteParams, type AgentCompleteResult, type PhaseEventParams, type PhaseStartResult, type PhaseEndResult, type CrossPhaseStatsResult, type FormatSignalsParams, type FormatSignalsResult, } from './cross-phase-handlers';
 //# sourceMappingURL=index.d.ts.map

package/dist/mcp/handlers/index.js

@@ -22,6 +22,8 @@ export { handleMemoryStore, handleMemoryRetrieve, handleMemoryQuery, handleMemor
 export { handlePipelineLoad, handlePipelineRun, handlePipelineList, handlePipelineValidate, getPipelineRegistry, getPipelineLoader, } from './pipeline-handlers.js';
 // Validation pipeline handler (BMAD-003)
 export { handleValidationPipeline, } from './validation-pipeline-handler.js';
+// Hypergraph query handler
+export { handleHypergraphQuery, } from './hypergraph-handler.js';
 // Cross-phase handlers
 export { handleCrossPhaseStore, handleCrossPhaseQuery, handleAgentComplete, handlePhaseStart, handlePhaseEnd, handleCrossPhaseStats, handleFormatSignals, handleCrossPhaseCleanup, resetCrossPhaseHandlers, } from './cross-phase-handlers';
 //# sourceMappingURL=index.js.map

package/dist/mcp/server.js

@@ -12,6 +12,8 @@ handleTaskSubmit, handleTaskList, handleTaskStatus, handleTaskCancel, handleTask
 handleAgentList, handleAgentSpawn, handleAgentMetrics, handleAgentStatus, 
 // Domain handlers
 handleTestGenerate, handleTestExecute, handleCoverageAnalyze, handleQualityAssess, handleSecurityScan, handleContractValidate, handleAccessibilityTest, handleChaosTest, handleDefectPredict, handleRequirementsValidate, handleCodeIndex, 
+// Hypergraph query handler
+handleHypergraphQuery, 
 // Memory handlers
 handleMemoryStore, handleMemoryRetrieve, handleMemoryQuery, handleMemoryDelete, handleMemoryUsage, handleMemoryShare, 
 // Cross-phase handlers
@@ -394,6 +396,23 @@ const DOMAIN_TOOLS = [
         },
         handler: handleCodeIndex,
     },
+    // Hypergraph Query
+    {
+        definition: {
+            name: 'mcp__agentic_qe__hypergraph_query',
+            description: 'Query the code knowledge hypergraph for untested functions, impacted tests, coverage gaps, and stats',
+            category: 'domain',
+            domain: 'code-intelligence',
+            lazyLoad: true,
+            parameters: [
+                { name: 'query', type: 'string', description: 'Query type: stats, untested, impacted, gaps', required: true },
+                { name: 'files', type: 'array', description: 'Changed files (required for "impacted" query)' },
+                { name: 'maxCoverage', type: 'number', description: 'Max coverage threshold for "gaps" query (default: 50)' },
+                { name: 'limit', type: 'number', description: 'Max results (default: 20)' },
+            ],
+        },
+        handler: handleHypergraphQuery,
+    },
     // Validation Pipeline (BMAD-003)
     {
         definition: {

package/dist/mcp/tool-scoping.js

@@ -14,6 +14,7 @@ const DEFAULT_SCOPES = {
             'test_execute_parallel',
             'coverage_analyze_sublinear',
             'code_index',
+            'hypergraph_query',
             'memory_query',
             'memory_retrieve',
             'model_route',
@@ -23,6 +24,7 @@ const DEFAULT_SCOPES = {
         allowed: [
             'coverage_analyze_sublinear',
             'code_index',
+            'hypergraph_query',
             'quality_assess',
             'memory_query',
             'memory_retrieve',
@@ -32,6 +34,7 @@ const DEFAULT_SCOPES = {
         allowed: [
             'security_scan_comprehensive',
             'code_index',
+            'hypergraph_query',
             'memory_query',
             'memory_retrieve',
         ],
@@ -41,6 +44,7 @@ const DEFAULT_SCOPES = {
             'quality_assess',
             'coverage_analyze_sublinear',
             'defect_predict',
+            'hypergraph_query',
             'memory_query',
             'memory_retrieve',
         ],
@@ -49,6 +53,7 @@ const DEFAULT_SCOPES = {
         allowed: [
             'defect_predict',
             'code_index',
+            'hypergraph_query',
             'memory_query',
             'memory_retrieve',
         ],

package/dist/shared/code-index-extractor.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Lightweight regex-based code entity extractor.
+ *
+ * Builds a CodeIndexResult from file paths by scanning for
+ * function/class/interface declarations, arrow function exports,
+ * class method definitions, and import statements.
+ *
+ * Uses async file I/O to avoid blocking the event loop on large codebases.
+ *
+ * Used by both init phase 06 and the code-intelligence coordinator
+ * to populate hypergraph tables.
+ */
+import type { CodeIndexResult } from '../integrations/ruvector/hypergraph-engine.js';
+export type { CodeIndexResult };
+/**
+ * Extract code entities and imports from a list of file paths.
+ * Returns a CodeIndexResult compatible with HypergraphEngine.buildFromIndexResult().
+ *
+ * Uses async I/O in batches to avoid blocking the event loop and
+ * exhausting file descriptors on large codebases.
+ */
+export declare function extractCodeIndex(paths: string[]): Promise<CodeIndexResult>;
+//# sourceMappingURL=code-index-extractor.d.ts.map

package/dist/shared/code-index-extractor.js

@@ -0,0 +1,101 @@
+/**
+ * Lightweight regex-based code entity extractor.
+ *
+ * Builds a CodeIndexResult from file paths by scanning for
+ * function/class/interface declarations, arrow function exports,
+ * class method definitions, and import statements.
+ *
+ * Uses async file I/O to avoid blocking the event loop on large codebases.
+ *
+ * Used by both init phase 06 and the code-intelligence coordinator
+ * to populate hypergraph tables.
+ */
+import { readFile } from 'fs/promises';
+// ============================================================================
+// Constants
+// ============================================================================
+/** Keywords that look like method definitions but are control flow */
+const CONTROL_FLOW_KEYWORDS = new Set([
+    'if', 'for', 'while', 'switch', 'catch', 'return',
+    'new', 'throw', 'import', 'export', 'constructor',
+]);
+/** Batch size for concurrent file reads to avoid fd exhaustion */
+const READ_BATCH_SIZE = 50;
+// ============================================================================
+// Extractor
+// ============================================================================
+/**
+ * Parse a single file's content into entities and imports.
+ * Pure function — no I/O.
+ */
+function parseFileContent(filePath, content) {
+    const lines = content.split('\n');
+    const entities = [];
+    const imports = [];
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        // Named function declarations: function foo() / export async function foo()
+        const funcMatch = line.match(/(?:export\s+)?(?:default\s+)?(?:async\s+)?function\s+(\w+)/);
+        if (funcMatch) {
+            entities.push({ type: 'function', name: funcMatch[1], lineStart: i + 1 });
+            continue;
+        }
+        // Arrow function exports: export const foo = (...) => / export const foo = async (
+        const arrowMatch = line.match(/(?:export\s+)?(?:const|let|var)\s+(\w+)\s*=\s*(?:async\s+)?(?:\([^)]*\)|[a-zA-Z_]\w*)\s*(?::\s*[^=]+)?\s*=>/);
+        if (arrowMatch) {
+            entities.push({ type: 'function', name: arrowMatch[1], lineStart: i + 1 });
+            continue;
+        }
+        // Class declarations: class Foo / export abstract class Foo
+        const classMatch = line.match(/(?:export\s+)?(?:default\s+)?(?:abstract\s+)?class\s+(\w+)/);
+        if (classMatch) {
+            entities.push({ type: 'class', name: classMatch[1], lineStart: i + 1 });
+            continue;
+        }
+        // Interface declarations: interface Foo / export interface Foo
+        const interfaceMatch = line.match(/(?:export\s+)?interface\s+(\w+)/);
+        if (interfaceMatch) {
+            entities.push({ type: 'interface', name: interfaceMatch[1], lineStart: i + 1 });
+            continue;
+        }
+        // Class method definitions: async doThing(...) / public static foo(
+        // Must be indented (inside a class body) and not a control flow keyword
+        const methodMatch = line.match(/^\s+(?:(?:public|private|protected|static|readonly|override|abstract|async)\s+)*(\w+)\s*(?:<[^>]*>)?\s*\([^)]*\)\s*(?::\s*[^{]+)?\s*\{?\s*$/);
+        if (methodMatch && !CONTROL_FLOW_KEYWORDS.has(methodMatch[1])) {
+            entities.push({ type: 'function', name: methodMatch[1], lineStart: i + 1 });
+            continue;
+        }
+        // Relative imports: import ... from './foo' / from '../bar'
+        const importMatch = line.match(/(?:import|from)\s+['"](\.[^'"]+)['"]/);
+        if (importMatch) {
+            imports.push(importMatch[1]);
+        }
+    }
+    return { path: filePath, entities, imports };
+}
+/**
+ * Extract code entities and imports from a list of file paths.
+ * Returns a CodeIndexResult compatible with HypergraphEngine.buildFromIndexResult().
+ *
+ * Uses async I/O in batches to avoid blocking the event loop and
+ * exhausting file descriptors on large codebases.
+ */
+export async function extractCodeIndex(paths) {
+    const files = [];
+    // Process files in batches to limit concurrency
+    for (let offset = 0; offset < paths.length; offset += READ_BATCH_SIZE) {
+        const batch = paths.slice(offset, offset + READ_BATCH_SIZE);
+        const results = await Promise.allSettled(batch.map(async (filePath) => {
+            const content = await readFile(filePath, 'utf-8');
+            return parseFileContent(filePath, content);
+        }));
+        for (const result of results) {
+            if (result.status === 'fulfilled') {
+                files.push(result.value);
+            }
+            // Skip rejected (unreadable files) silently
+        }
+    }
+    return { files };
+}
+//# sourceMappingURL=code-index-extractor.js.map

package/dist/shared/parsers/multi-language-parser.d.ts

@@ -128,11 +128,14 @@ declare class DartParser implements ILanguageParser {
 }
 /**
  * Registry of all language parsers.
- * Provides regex-based parsing for Python, Java, C#, Go, Rust, Swift, Kotlin, Dart.
+ * For Python, Java, C#, Rust, Swift: tries WASM parser first, falls back to regex.
+ * For Go, Kotlin, Dart: uses regex parser directly.
  */
 export declare class TreeSitterParserRegistry {
     private parsers;
+    private _wasmInitPromise;
     constructor();
+    private _tryLoadWasmParsers;
     register(parser: ILanguageParser): void;
     getParser(language: SupportedLanguage): ILanguageParser | undefined;
     parseFile(content: string, filePath: string, language: SupportedLanguage): Promise<ParsedFile | undefined>;

package/dist/shared/parsers/multi-language-parser.js

@@ -7,6 +7,7 @@
  * 1. joinMultiLineSignatures — collapses multi-line function/class declarations into single logical lines
  * 2. matchBalancedBrackets — handles nested generics like Map<String, List<Foo>> correctly
  */
+import { createLogger } from '../../logging/logger-factory.js';
 // ============================================================================
 // Shared Parsing Utilities
 // ============================================================================
@@ -1230,13 +1231,53 @@ class DartParser {
 // ============================================================================
 // Parser Registry
 // ============================================================================
+const registryLogger = createLogger('ParserRegistry');
+/** Languages that have WASM parser support */
+const WASM_SUPPORTED_LANGUAGES = ['python', 'java', 'csharp', 'rust', 'swift'];
+/**
+ * Wraps a WASM parser with automatic fallback to a regex parser.
+ * Logs a user-facing warning when fallback occurs.
+ */
+class FallbackParser {
+    language;
+    supportedExtensions;
+    wasmParser;
+    regexParser;
+    wasmFailCount = 0;
+    static MAX_WASM_RETRIES = 3;
+    constructor(wasmParser, regexParser) {
+        this.wasmParser = wasmParser;
+        this.regexParser = regexParser;
+        this.language = wasmParser.language;
+        this.supportedExtensions = wasmParser.supportedExtensions;
+    }
+    async parseFile(content, filePath) {
+        if (this.wasmFailCount < FallbackParser.MAX_WASM_RETRIES) {
+            try {
+                return await this.wasmParser.parseFile(content, filePath);
+            }
+            catch (err) {
+                this.wasmFailCount++;
+                const msg = err instanceof Error ? err.message : String(err);
+                const permanent = this.wasmFailCount >= FallbackParser.MAX_WASM_RETRIES;
+                registryLogger.warn(`[${this.language}] tree-sitter WASM parser failed (attempt ${this.wasmFailCount}/${FallbackParser.MAX_WASM_RETRIES}): ${msg}. ` +
+                    `Falling back to regex parser (~97-98% accuracy). ` +
+                    (permanent ? 'Set AQE_PARSER_REGEX_ONLY=1 to silence this warning.' : 'Will retry WASM on next parse.'));
+            }
+        }
+        return this.regexParser.parseFile(content, filePath);
+    }
+}
 /**
  * Registry of all language parsers.
- * Provides regex-based parsing for Python, Java, C#, Go, Rust, Swift, Kotlin, Dart.
+ * For Python, Java, C#, Rust, Swift: tries WASM parser first, falls back to regex.
+ * For Go, Kotlin, Dart: uses regex parser directly.
  */
 export class TreeSitterParserRegistry {
     parsers = new Map();
+    _wasmInitPromise = null;
     constructor() {
+        // Register regex parsers for all 8 languages immediately
         this.register(new PythonParser());
         this.register(new JavaParser());
         this.register(new CSharpParser());
@@ -1245,6 +1286,31 @@ export class TreeSitterParserRegistry {
         this.register(new SwiftParser());
         this.register(new KotlinParser());
         this.register(new DartParser());
+        // Kick off async WASM parser loading (non-blocking)
+        this._wasmInitPromise = this._tryLoadWasmParsers();
+    }
+    async _tryLoadWasmParsers() {
+        try {
+            const mod = await import('./tree-sitter-wasm-parser.js');
+            if (!mod.isWasmAvailable()) {
+                registryLogger.info('tree-sitter WASM parsers disabled or unavailable. Using regex parsers (~97-98% accuracy). ' +
+                    'Set AQE_PARSER_REGEX_ONLY=0 or ensure web-tree-sitter is installed to enable WASM.');
+                return;
+            }
+            const wasmParsers = mod.createWasmParsers();
+            // Wrap each WASM parser with fallback to the existing regex parser
+            for (const lang of WASM_SUPPORTED_LANGUAGES) {
+                const wasmParser = wasmParsers.get(lang);
+                const regexParser = this.parsers.get(lang);
+                if (wasmParser && regexParser) {
+                    this.parsers.set(lang, new FallbackParser(wasmParser, regexParser));
+                }
+            }
+            registryLogger.info('tree-sitter WASM parsers available for: ' + WASM_SUPPORTED_LANGUAGES.join(', '));
+        }
+        catch {
+            registryLogger.info('tree-sitter WASM parser module not available. Using regex parsers for all languages.');
+        }
     }
     register(parser) {
         this.parsers.set(parser.language, parser);
@@ -1253,6 +1319,12 @@ export class TreeSitterParserRegistry {
         return this.parsers.get(language);
     }
     async parseFile(content, filePath, language) {
+        // Ensure WASM init has completed (or failed) before first parse.
+        // After the first call, the promise is already resolved so this is a no-op.
+        if (this._wasmInitPromise) {
+            await this._wasmInitPromise;
+            this._wasmInitPromise = null;
+        }
         const parser = this.parsers.get(language);
         if (!parser)
             return undefined;

package/dist/shared/parsers/tree-sitter-wasm-parser.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Tree-sitter WASM Parser (ADR-076 Amendment 2026-03-24)
+ *
+ * Provides AST-based parsing for Python, Java, C#, Rust, Swift using
+ * web-tree-sitter WASM grammars. Achieves ~100% accuracy for identifying
+ * functions, classes, imports, properties, and complexity — eliminating
+ * the ~2-3% edge cases (code in strings, complex generics) that regex misses.
+ *
+ * Lazy-loads WASM grammars on first parse per language.
+ * Falls back to regex parsers with user-facing log warnings when WASM
+ * initialization fails (missing dependency, incompatible Node version, etc.).
+ */
+import type { SupportedLanguage } from '../types/test-frameworks.js';
+import type { ILanguageParser, ParsedFile } from './interfaces.js';
+export declare class TreeSitterWASMParser implements ILanguageParser {
+    readonly language: SupportedLanguage;
+    readonly supportedExtensions: string[];
+    constructor(language: SupportedLanguage, extensions: string[]);
+    parseFile(content: string, filePath: string): Promise<ParsedFile>;
+    private extractFromAST;
+}
+export declare function createWasmParsers(): Map<SupportedLanguage, ILanguageParser>;
+/**
+ * Check if web-tree-sitter WASM is available in this environment.
+ * Returns true if the dependency is installed; does NOT initialize WASM.
+ */
+export declare function isWasmAvailable(): boolean;
+/**
+ * Reset internal state — for testing only.
+ */
+export declare function _resetWasmState(): void;
+//# sourceMappingURL=tree-sitter-wasm-parser.d.ts.map