refactor(core): parse once per file, not 3x — extractors take pre-computed AST

Address review findings:
1. runQueries doing too much: extracted runAllAstQueries() that parses
   once and runs all 12 queries. Extractors now take a pre-computed
   Map<string, number> instead of matcher+filePath (pure functions).
2. 3x parsing eliminated: analyzeFileFromIndex and analyzeFileWithDocs
   call runAllAstQueries once, pass results to all 3 extractors.
3. Extractors are now synchronous pure functions — easier to test,
   no async overhead, no hidden parsing.

Tests updated to match new signatures. Same 51 test count, same coverage.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: prosdev

.claude/scratchpad.md

@@ -17,6 +17,10 @@
 - Vue/Svelte SFC support — `.vue`/`.svelte` files have embedded `<script lang="ts">` blocks. Would need script block extraction before tree-sitter parsing. Lower priority — co-located `.ts` files in those projects already get full analysis.
 - Swap `WasmPatternMatcher` to `@ast-grep/napi` if bulk scanning perf becomes an issue (~4x faster native Rust). Interface is ready; implementation is mechanical.
 
+## Test Gaps
+
+- **InspectAdapter integration test with PatternMatcher.** The InspectAdapter test constructs without a `patternMatcher` — the AST path is never exercised through the MCP layer. Needs a test that constructs `InspectAdapter` with `createPatternMatcher()`, mocks the search service, calls `execute()`, and verifies AST-enhanced results flow through. Requires mock search service setup — larger integration test scope.
+
 ## Notes
 
 - Both pattern analysis paths (index vs scan) must use the same pure extractors from 1.1 to avoid drift. Test this explicitly.

packages/core/src/pattern-matcher/__tests__/wasm-matcher.test.ts

@@ -16,6 +16,7 @@ import {
   extractImportStyleWithAst,
   extractTypeCoverageFromSignatures,
   extractTypeCoverageWithAst,
+  runAllAstQueries,
 } from '../../services/pattern-analysis-service';
 import {
   ALL_QUERIES,
@@ -404,50 +405,49 @@ describe('extractErrorHandlingWithAst', () => {
 
   it('throw + try-catch → mixed', async () => {
     const source = 'try { validate(x); } catch (e) { throw new Error("failed"); }';
-    const result = await extractErrorHandlingWithAst(source, 'test.ts', matcher);
-    expect(result.style).toBe('mixed');
+    const ast = await runAllAstQueries(source, 'test.ts', matcher);
+    expect(extractErrorHandlingWithAst(source, ast).style).toBe('mixed');
   });
 
   it('throw only → throw', async () => {
     const source = 'throw new Error("bad");';
-    const result = await extractErrorHandlingWithAst(source, 'test.ts', matcher);
-    expect(result.style).toBe('throw');
+    const ast = await runAllAstQueries(source, 'test.ts', matcher);
+    expect(extractErrorHandlingWithAst(source, ast).style).toBe('throw');
   });
 
   it('try-catch without throw → falls through to regex', async () => {
-    // try-catch alone is a mechanism, not a style — falls through to regex
     const source = 'try { x(); } catch (e) { console.log(e); }';
-    const result = await extractErrorHandlingWithAst(source, 'test.ts', matcher);
+    const ast = await runAllAstQueries(source, 'test.ts', matcher);
     // regex sees no throw/Result either → 'unknown'
-    expect(result.style).toBe('unknown');
+    expect(extractErrorHandlingWithAst(source, ast).style).toBe('unknown');
   });
 
-  it('Result<T> from regex + try-catch from AST → mixed', async () => {
+  it('Result<T> from regex + try-catch from AST → result', async () => {
     const source = 'function f(): Result<string> { try { return ok(); } catch { return err(); } }';
-    const result = await extractErrorHandlingWithAst(source, 'test.ts', matcher);
-    // regex detects Result<T>, AST detects try-catch but no throw → regex returns 'result'
-    // then the extractor sees hasThrow=false, hasResultRegex=true → returns regex result
-    expect(result.style).toBe('result');
+    const ast = await runAllAstQueries(source, 'test.ts', matcher);
+    expect(extractErrorHandlingWithAst(source, ast).style).toBe('result');
   });
 
-  it('promise.catch only → unknown (no style mapping)', async () => {
+  it('promise.catch only → unknown', async () => {
     const source = 'fetch("/api").catch(log);';
-    const result = await extractErrorHandlingWithAst(source, 'test.ts', matcher);
-    expect(result.style).toBe('unknown');
+    const ast = await runAllAstQueries(source, 'test.ts', matcher);
+    expect(extractErrorHandlingWithAst(source, ast).style).toBe('unknown');
   });
 
-  it('matcher=undefined → identical to regex', async () => {
+  it('empty AST map → identical to regex', () => {
     const source = 'throw new Error("bad"); function f(): Result<string> {}';
-    const withMatcher = await extractErrorHandlingWithAst(source, 'test.ts', undefined);
+    const result = extractErrorHandlingWithAst(source, new Map());
     const regexOnly = extractErrorHandlingFromContent(source);
-    expect(withMatcher).toEqual(regexOnly);
+    expect(result).toEqual(regexOnly);
   });
 
-  it('unsupported extension → falls back to regex', async () => {
+  it('unsupported extension → runAllAstQueries returns empty → regex', async () => {
     const source = 'throw new Error("bad");';
-    const result = await extractErrorHandlingWithAst(source, 'test.py', matcher);
-    const regexOnly = extractErrorHandlingFromContent(source);
-    expect(result).toEqual(regexOnly);
+    const ast = await runAllAstQueries(source, 'test.py', matcher);
+    expect(ast.size).toBe(0); // unsupported language
+    expect(extractErrorHandlingWithAst(source, ast)).toEqual(
+      extractErrorHandlingFromContent(source)
+    );
   });
 });
 
@@ -460,29 +460,29 @@ describe('extractImportStyleWithAst', () => {
 
   it('static ESM + dynamic import → esm', async () => {
     const source = 'import { foo } from "./bar";\nconst m = await import("./baz");';
-    const result = await extractImportStyleWithAst(source, 'test.ts', matcher);
+    const ast = await runAllAstQueries(source, 'test.ts', matcher);
+    const result = extractImportStyleWithAst(source, ast);
     expect(result.style).toBe('esm');
-    // importCount should include the dynamic import
     expect(result.importCount).toBeGreaterThan(1);
   });
 
   it('require detected by AST → cjs', async () => {
     const source = 'const fs = require("fs");';
-    const result = await extractImportStyleWithAst(source, 'test.ts', matcher);
-    expect(result.style).toBe('cjs');
+    const ast = await runAllAstQueries(source, 'test.ts', matcher);
+    expect(extractImportStyleWithAst(source, ast).style).toBe('cjs');
   });
 
   it('mixed: ESM import + require → mixed', async () => {
     const source = 'import foo from "./bar";\nconst fs = require("fs");';
-    const result = await extractImportStyleWithAst(source, 'test.ts', matcher);
-    expect(result.style).toBe('mixed');
+    const ast = await runAllAstQueries(source, 'test.ts', matcher);
+    expect(extractImportStyleWithAst(source, ast).style).toBe('mixed');
   });
 
-  it('matcher=undefined → identical to regex', async () => {
+  it('empty AST map → identical to regex', () => {
     const source = 'import foo from "./bar";';
-    const withMatcher = await extractImportStyleWithAst(source, 'test.ts', undefined);
-    const regexOnly = extractImportStyleFromContent(source);
-    expect(withMatcher).toEqual(regexOnly);
+    expect(extractImportStyleWithAst(source, new Map())).toEqual(
+      extractImportStyleFromContent(source)
+    );
   });
 });
 
@@ -498,44 +498,45 @@ describe('extractTypeCoverageWithAst', () => {
       'const add = (a: number, b: number): number => a + b;',
       'function greet(name: string): string { return name; }',
     ].join('\n');
-    const result = await extractTypeCoverageWithAst(source, 'test.ts', matcher, []);
+    const ast = await runAllAstQueries(source, 'test.ts', matcher);
+    const result = extractTypeCoverageWithAst(source, ast, []);
     expect(result.coverage).toBe('full');
     expect(result.annotatedCount).toBe(2);
     expect(result.totalCount).toBe(2);
   });
 
-  it('some functions typed → partial (accurate denominator)', async () => {
+  it('some functions typed → minimal (accurate denominator)', async () => {
     const source = [
       'const typed = (a: number): number => a;',
       'const untyped = (a) => a;',
       'function alsoUntyped(x) { return x; }',
     ].join('\n');
-    const result = await extractTypeCoverageWithAst(source, 'test.ts', matcher, []);
+    const ast = await runAllAstQueries(source, 'test.ts', matcher);
+    const result = extractTypeCoverageWithAst(source, ast, []);
     expect(result.coverage).toBe('minimal'); // 1 of 3
     expect(result.annotatedCount).toBe(1);
     expect(result.totalCount).toBe(3);
   });
 
   it('no functions → none', async () => {
     const source = 'const x = 1;';
-    const result = await extractTypeCoverageWithAst(source, 'test.ts', matcher, []);
-    expect(result.coverage).toBe('none');
+    const ast = await runAllAstQueries(source, 'test.ts', matcher);
+    expect(extractTypeCoverageWithAst(source, ast, []).coverage).toBe('none');
   });
 
   it('AST detects arrows that signatures miss', async () => {
-    // Signatures from index don't include arrow functions
     const source = 'const add = (a: number, b: number): number => a + b;';
-    const signatures: string[] = []; // index has no signatures for this
-    const result = await extractTypeCoverageWithAst(source, 'test.ts', matcher, signatures);
+    const ast = await runAllAstQueries(source, 'test.ts', matcher);
+    const result = extractTypeCoverageWithAst(source, ast, []);
     expect(result.annotatedCount).toBe(1);
     expect(result.totalCount).toBe(1);
     expect(result.coverage).toBe('full');
   });
 
-  it('matcher=undefined → identical to regex signatures', async () => {
+  it('empty AST map → identical to regex signatures', () => {
     const signatures = ['function foo(x: string): number'];
-    const withMatcher = await extractTypeCoverageWithAst('', 'test.ts', undefined, signatures);
-    const regexOnly = extractTypeCoverageFromSignatures(signatures);
-    expect(withMatcher).toEqual(regexOnly);
+    expect(extractTypeCoverageWithAst('', new Map(), signatures)).toEqual(
+      extractTypeCoverageFromSignatures(signatures)
+    );
   });
 });

packages/core/src/services/pattern-analysis-service.ts

@@ -7,12 +7,8 @@
 
 import * as fs from 'node:fs/promises';
 import * as path from 'node:path';
-import {
-  ERROR_HANDLING_QUERIES,
-  IMPORT_STYLE_QUERIES,
-  TYPE_COVERAGE_QUERIES,
-} from '../pattern-matcher/rules';
-import type { PatternMatcher, PatternMatchRule } from '../pattern-matcher/wasm-matcher';
+import { ALL_QUERIES } from '../pattern-matcher/rules';
+import type { PatternMatcher } from '../pattern-matcher/wasm-matcher';
 import { resolveLanguage } from '../pattern-matcher/wasm-matcher';
 import { scanRepository } from '../scanner';
 import type { Document } from '../scanner/types';
@@ -110,34 +106,34 @@ export function extractTypeCoverageFromSignatures(signatures: string[]): TypeAnn
 }
 
 // ========================================================================
-// AST-Enhanced Extractors — use PatternMatcher when available, regex fallback
+// AST-Enhanced Extractors — accept pre-computed AST results, regex fallback
 // ========================================================================
 
 /**
- * Run AST queries if matcher and language are available, else return empty map.
+ * Run all AST queries in a single parse. Call once per file, pass results
+ * to each extractor. Avoids parsing the same source 3 times.
+ *
+ * Returns empty map when matcher or filePath is unavailable (regex fallback).
  */
-async function runAstQueries(
+export async function runAllAstQueries(
   content: string,
   filePath: string | undefined,
-  matcher: PatternMatcher | undefined,
-  queries: PatternMatchRule[]
+  matcher: PatternMatcher | undefined
 ): Promise<Map<string, number>> {
   if (!matcher || !filePath) return new Map();
   const language = resolveLanguage(filePath);
   if (!language) return new Map();
-  return matcher.match(content, language, queries);
+  return matcher.match(content, language, ALL_QUERIES);
 }
 
 /**
- * Extract error handling using AST (preferred) + regex (fallback/supplement).
+ * Extract error handling using pre-computed AST results + regex fallback.
  */
-export async function extractErrorHandlingWithAst(
+export function extractErrorHandlingWithAst(
   content: string,
-  filePath?: string,
-  matcher?: PatternMatcher
-): Promise<ErrorHandlingPattern> {
+  ast: Map<string, number>
+): ErrorHandlingPattern {
   const regex = extractErrorHandlingFromContent(content);
-  const ast = await runAstQueries(content, filePath, matcher, ERROR_HANDLING_QUERIES);
 
   if (ast.size === 0) return regex;
 
@@ -158,15 +154,13 @@ export async function extractErrorHandlingWithAst(
 }
 
 /**
- * Extract import style using AST (preferred) + regex (fallback/supplement).
+ * Extract import style using pre-computed AST results + regex fallback.
  */
-export async function extractImportStyleWithAst(
+export function extractImportStyleWithAst(
   content: string,
-  filePath?: string,
-  matcher?: PatternMatcher
-): Promise<ImportStylePattern> {
+  ast: Map<string, number>
+): ImportStylePattern {
   const regex = extractImportStyleFromContent(content);
-  const ast = await runAstQueries(content, filePath, matcher, IMPORT_STYLE_QUERIES);
 
   if (ast.size === 0) return regex;
 
@@ -192,17 +186,14 @@ export async function extractImportStyleWithAst(
 }
 
 /**
- * Extract type coverage using AST (preferred) + regex signatures (supplement).
+ * Extract type coverage using pre-computed AST results + regex signatures.
  */
-export async function extractTypeCoverageWithAst(
+export function extractTypeCoverageWithAst(
   content: string,
-  filePath?: string,
-  matcher?: PatternMatcher,
+  ast: Map<string, number>,
   signatures?: string[]
-): Promise<TypeAnnotationPattern> {
-  // Start with signature-based detection (from index or ts-morph)
+): TypeAnnotationPattern {
   const regex = extractTypeCoverageFromSignatures(signatures ?? []);
-  const ast = await runAstQueries(content, filePath, matcher, TYPE_COVERAGE_QUERIES);
 
   if (ast.size === 0) return regex;
 
@@ -287,18 +278,15 @@ export class PatternAnalysisService {
       .map((d) => (d.metadata.signature as string) || '')
       .filter(Boolean);
 
-    const [importStyle, errorHandling, typeAnnotations] = await Promise.all([
-      extractImportStyleWithAst(content, filePath, this.config.patternMatcher),
-      extractErrorHandlingWithAst(content, filePath, this.config.patternMatcher),
-      extractTypeCoverageWithAst(content, filePath, this.config.patternMatcher, signatures),
-    ]);
+    // Parse once, run all 12 AST queries, pass results to each extractor
+    const ast = await runAllAstQueries(content, filePath, this.config.patternMatcher);
 
     return {
       fileSize: { lines, bytes },
       testing,
-      importStyle,
-      errorHandling,
-      typeAnnotations,
+      importStyle: extractImportStyleWithAst(content, ast),
+      errorHandling: extractErrorHandlingWithAst(content, ast),
+      typeAnnotations: extractTypeCoverageWithAst(content, ast, signatures),
     };
   }
 
@@ -389,18 +377,15 @@ export class PatternAnalysisService {
       .map((d) => d.metadata.signature || '')
       .filter(Boolean);
 
-    const [importStyle, errorHandling, typeAnnotations] = await Promise.all([
-      extractImportStyleWithAst(content, filePath, this.config.patternMatcher),
-      extractErrorHandlingWithAst(content, filePath, this.config.patternMatcher),
-      extractTypeCoverageWithAst(content, filePath, this.config.patternMatcher, signatures),
-    ]);
+    // Parse once, run all 12 AST queries, pass results to each extractor
+    const ast = await runAllAstQueries(content, filePath, this.config.patternMatcher);
 
     return {
       fileSize: { lines: content.split('\n').length, bytes: stat.size },
       testing,
-      importStyle,
-      errorHandling,
-      typeAnnotations,
+      importStyle: extractImportStyleWithAst(content, ast),
+      errorHandling: extractErrorHandlingWithAst(content, ast),
+      typeAnnotations: extractTypeCoverageWithAst(content, ast, signatures),
     };
   }