agentic-qe 3.8.7 → 3.8.9

package/dist/mcp/tools/coverage-analysis/index.d.ts

@@ -17,6 +17,10 @@ export interface CoverageAnalyzeParams {
     includeRiskScoring?: boolean;
     mlPowered?: boolean;
     dryRun?: boolean;
+    /** Source language hint (java, csharp, go, rust, kotlin, swift, dart) */
+    language?: string;
+    /** Coverage format hint (lcov, json, jacoco, dotcover, tarpaulin, gocover, kover, xcresult) */
+    coverageFormat?: string;
     [key: string]: unknown;
 }
 export interface CoverageThresholds {
@@ -31,6 +35,10 @@ export interface CoverageAnalyzeResult {
     thresholdsPassed: boolean;
     riskScore?: number;
     trends?: CoverageTrend;
+    /** Detected or specified source language */
+    language?: string;
+    /** Coverage format used for parsing */
+    format?: string;
 }
 export interface CoverageSummary {
     lines: CoverageMetric;
@@ -65,6 +73,10 @@ export interface CoverageGapsParams {
     limit?: number;
     prioritization?: 'complexity' | 'criticality' | 'change-frequency' | 'ml-confidence';
     includeGhost?: boolean;
+    /** Source language filter */
+    language?: string;
+    /** Coverage format hint */
+    coverageFormat?: string;
     [key: string]: unknown;
 }
 export interface CoverageGapsResult {

package/dist/mcp/tools/coverage-analysis/index.js

@@ -89,7 +89,7 @@ export class CoverageAnalyzeTool extends MCPToolBase {
         return this.analyzerService;
     }
     async execute(params, context) {
-        const { target = '.', coverageFile, thresholds = { lines: 80, branches: 70, functions: 80, statements: 80 }, includeRisk = false, includeRiskScoring = false, dryRun = false, } = params;
+        const { target = '.', coverageFile, thresholds = { lines: 80, branches: 70, functions: 80, statements: 80 }, includeRisk = false, includeRiskScoring = false, dryRun = false, coverageFormat, language, } = params;
         const shouldIncludeRisk = includeRisk || includeRiskScoring;
         try {
             this.emitStream(context, {
@@ -108,7 +108,7 @@ export class CoverageAnalyzeTool extends MCPToolBase {
             let parsedReport = null;
             if (coverageFile) {
                 try {
-                    parsedReport = await parseCoverage(coverageFile, target);
+                    parsedReport = await parseCoverage(coverageFile, target, coverageFormat, language);
                 }
                 catch (parseError) {
                     // Return error - don't silently fall back to fake data
@@ -207,6 +207,9 @@ export class CoverageAnalyzeTool extends MCPToolBase {
                 message: `Coverage analysis complete: ${summary.lines.percentage}% lines covered`,
                 progress: 100,
             });
+            // Resolve language: explicit param > detected from report > undefined
+            const detectedLanguage = params.language || parsedReport.language;
+            const detectedFormat = parsedReport.format;
             return {
                 success: true,
                 data: {
@@ -215,6 +218,8 @@ export class CoverageAnalyzeTool extends MCPToolBase {
                     thresholdsPassed,
                     riskScore,
                     trends,
+                    language: detectedLanguage,
+                    format: detectedFormat,
                 },
             };
         }
@@ -297,7 +302,7 @@ export class CoverageGapsTool extends MCPToolBase {
         return this.gapService;
     }
     async execute(params, context) {
-        const { target = '.', coverageFile, minRisk = 0.3, limit = 20, prioritization = 'complexity', } = params;
+        const { target = '.', coverageFile, minRisk = 0.3, limit = 20, prioritization = 'complexity', coverageFormat, language, } = params;
         try {
             this.emitStream(context, {
                 status: 'detecting',
@@ -310,7 +315,7 @@ export class CoverageGapsTool extends MCPToolBase {
             let parsedReport = null;
             if (coverageFile) {
                 try {
-                    parsedReport = await parseCoverage(coverageFile, target);
+                    parsedReport = await parseCoverage(coverageFile, target, coverageFormat, language);
                 }
                 catch (parseError) {
                     return {
@@ -527,6 +532,15 @@ const COVERAGE_ANALYZE_SCHEMA = {
             description: 'Use ML-powered analysis (vector similarity)',
             default: false,
         },
+        language: {
+            type: 'string',
+            description: 'Source language hint (java, csharp, go, rust, kotlin, swift, dart, typescript, python)',
+        },
+        coverageFormat: {
+            type: 'string',
+            description: 'Coverage format hint',
+            enum: ['lcov', 'json', 'jacoco', 'dotcover', 'tarpaulin', 'gocover', 'kover', 'xcresult'],
+        },
     },
 };
 const COVERAGE_GAPS_SCHEMA = {
@@ -566,6 +580,15 @@ const COVERAGE_GAPS_SCHEMA = {
             description: 'Include ADR-059 ghost intent coverage analysis (detect untested behavioral intents)',
             default: false,
         },
+        language: {
+            type: 'string',
+            description: 'Source language filter (java, csharp, go, rust, kotlin, swift, dart)',
+        },
+        coverageFormat: {
+            type: 'string',
+            description: 'Coverage format hint',
+            enum: ['lcov', 'json', 'jacoco', 'dotcover', 'tarpaulin', 'gocover', 'kover', 'xcresult'],
+        },
     },
 };
 //# sourceMappingURL=index.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