agentic-qe 3.8.7 → 3.8.8

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