From 1da87ac32a9157065ef43bc36bd8d2eb870e95df Mon Sep 17 00:00:00 2001
From: prosdev <prosdevlab@gmail.com>
Date: Tue, 31 Mar 2026 01:41:13 -0700
Subject: [PATCH 1/8] =?UTF-8?q?docs:=20revise=201.5=20plan=20=E2=80=94=20t?=
 =?UTF-8?q?ree-sitter=20WASM=20queries,=20not=20ast-grep=20CLI?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Replace ast-grep CLI approach with tree-sitter queries using WASM we
already bundle. Key changes: PatternMatcher interface for future NAPI
swap, PatternRule DSL translated to S-expressions, zero new dependencies.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---
 .../1.5-ast-pattern-analysis.md               | 632 +++++++++++-------
 .claude/scratchpad.md                         |   5 +-
 2 files changed, 407 insertions(+), 230 deletions(-)

diff --git a/.claude/da-plans/mcp/phase-1-mcp-tools-improvement/1.5-ast-pattern-analysis.md b/.claude/da-plans/mcp/phase-1-mcp-tools-improvement/1.5-ast-pattern-analysis.md
index 9e4a1a9..d4e08c3 100644
--- a/.claude/da-plans/mcp/phase-1-mcp-tools-improvement/1.5-ast-pattern-analysis.md
+++ b/.claude/da-plans/mcp/phase-1-mcp-tools-improvement/1.5-ast-pattern-analysis.md
@@ -1,292 +1,468 @@
-# Part 1.5: AST-Based Pattern Analysis via ast-grep
+# Part 1.5: AST-Based Pattern Analysis via Tree-Sitter Queries
 
-> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task.
+**Status:** Draft (revised — addressed review findings)
 
-**Goal:** Replace regex-based pattern detection in `dev_patterns` with ast-grep's tree-sitter AST matching for significantly more accurate analysis.
+**Goal:** Replace regex-based pattern detection in `dev_patterns` with tree-sitter
+query-based AST matching for more accurate analysis. Use the WASM tree-sitter
+runtime we already bundle. Design for future swap to `@ast-grep/napi` if needed.
 
 **User stories:** US-11
 
-**Inspiration:** [ast-grep](https://github.com/ast-grep/ast-grep) — MIT licensed, structural code search using tree-sitter AST patterns. Has its own [MCP server](https://github.com/ast-grep/ast-grep-mcp) validating the approach.
-
-**Files:**
-- Create: `packages/core/src/services/ast-patterns.ts`
-- Create: `packages/core/src/services/__tests__/ast-patterns.test.ts`
-- Modify: `packages/core/src/services/pattern-analysis-service.ts`
+**Inspiration:** Studied [ast-grep](https://github.com/ast-grep/ast-grep) architecture
+(custom matcher on tree-sitter AST). Our approach is simpler: use tree-sitter's
+built-in query API with S-expression constants. No query builder — YAGNI.
 
 ---
 
-## Why ast-grep over regex
-
-Current regex approach misses common patterns:
+## Key design decisions (from two review rounds)
 
-| Pattern | Regex detects | ast-grep detects |
-|---------|--------------|-----------------|
-| `try { } catch (e) { }` | No | Yes — structural match |
-| `promise.catch(handler)` | No | Yes — method call pattern |
-| Custom error classes | No | Yes — class extends Error |
-| Async error handling | No | Yes — await in try/catch |
-| Type annotations on arrow functions | Fragile | Yes — AST node type |
+**Round 1 (query builder removal):**
+Dropped the `PatternRule` DSL and `query-builder.ts` (~150 lines of template code).
+S-expressions are string constants — simpler, less error-prone, directly testable.
 
-ast-grep is a CLI tool (`npm install -g @ast-grep/cli`) that we shell out to. No need to import its internals — just call it with YAML rules and parse JSON output.
+**Round 2 (WASM/grammar concerns):**
+- Bundle both TypeScript (~2.3MB) and TSX (~2.3MB) WASM grammars. React codebases
+  are mostly `.tsx` — skipping them would miss the majority of files. Same queries
+  work on both grammars. Total ~4.9MB WASM bundle (including Go).
+- `WasmPatternMatcher` caches a parser instance and calls `tree.delete()` after each
+  `match()` to prevent WASM heap memory leaks.
+- `await-in-try` query is intentionally narrow (const/let declarations only). Documented.
+- `error-class` query matches any `extends_clause`, not just `extends Error` literally.
+  Custom error hierarchies (`extends BaseError`, `extends HttpError`) are common.
 
 ---
 
-## Task 1: Add ast-grep as optional dependency
+## Verified S-expressions
 
-- [ ] **Step 1: Check if ast-grep is available**
+All queries validated against `web-tree-sitter@0.25.10` + `tree-sitter-wasms@0.1.13`
+TypeScript grammar by parsing real snippets and inspecting AST output.
+
+### Error handling (5 rules)
 
 ```typescript
-// In packages/core/src/services/ast-patterns.ts
-
-import { execFileSync, execSync } from 'node:child_process';
-import * as fs from 'node:fs';
-import * as os from 'node:os';
-import * as path from 'node:path';
-
-let _astGrepAvailable: boolean | null = null;
-
-/**
- * Check if ast-grep CLI is available. Memoized per process.
- */
-export function hasAstGrep(): boolean {
-  if (_astGrepAvailable !== null) return _astGrepAvailable;
-  try {
-    execSync('ast-grep --version', { stdio: 'pipe', timeout: 5000 });
-    _astGrepAvailable = true;
-  } catch {
-    _astGrepAvailable = false;
-  }
-  return _astGrepAvailable;
-}
+const ERROR_HANDLING_QUERIES = {
+  // Matches any try { } catch { } block
+  'try-catch': '(try_statement) @match',
+
+  // Matches throw statements: throw new Error(...), throw err, etc.
+  'throw': '(throw_statement) @match',
+
+  // Matches .catch() method calls: promise.catch(handler)
+  'promise-catch': '(call_expression function: (member_expression property: (property_identifier) @method (#eq? @method "catch"))) @match',
+
+  // Matches await inside try blocks — intentionally narrow: only catches
+  // const/let declarations with await (e.g., `const data = await fetch(...)`)
+  // Does NOT catch bare `await foo()` as expression statements or await
+  // nested inside if/for within try. This is a known limitation.
+  'await-in-try': '(try_statement body: (statement_block (lexical_declaration (variable_declarator value: (await_expression))))) @match',
+
+  // Matches class declarations with any extends clause.
+  // Catches: class AppError extends Error, class HttpError extends BaseError, etc.
+  // May have false positives for non-error classes with extends, but in practice
+  // this is rare in error-handling analysis context.
+  'error-class': '(class_declaration (class_heritage (extends_clause))) @match',
+};
 ```
 
-- [ ] **Step 2: Write test**
+### Import style (3 rules)
 
 ```typescript
-describe('ast-grep integration', () => {
-  it('should detect if ast-grep is available', () => {
-    // This test passes regardless — just checks the function works
-    const available = hasAstGrep();
-    expect(typeof available).toBe('boolean');
-  });
-});
+const IMPORT_STYLE_QUERIES = {
+  // Matches dynamic import(): await import('./module')
+  'dynamic-import': '(call_expression function: (import)) @match',
+
+  // Matches re-exports: export { foo } from './bar'
+  're-export': '(export_statement source: (string)) @match',
+
+  // Matches require() calls: const fs = require('fs')
+  'require': '(call_expression function: (identifier) @fn (#eq? @fn "require")) @match',
+};
 ```
 
-- [ ] **Step 3: Commit**
+### Type coverage (2 rules)
 
-```bash
-git add packages/core/src/services/ast-patterns.ts packages/core/src/services/__tests__/ast-patterns.test.ts
-git commit -m "feat(core): add ast-grep availability check"
+```typescript
+const TYPE_COVERAGE_QUERIES = {
+  // Matches arrow functions WITH return type annotation
+  // This is the main win over regex — regex is fragile on (): Type => ...
+  'arrow-return-type': '(arrow_function return_type: (type_annotation)) @match',
+
+  // Matches function declarations WITH return type annotation
+  'function-return-type': '(function_declaration return_type: (type_annotation)) @match',
+};
 ```
 
 ---
 
-## Task 2: Define AST pattern rules for error handling
+## Architecture
 
-ast-grep uses YAML rules. We define patterns for the 5 categories we analyze.
+```
+PatternAnalysisService
+    │
+    │ calls (optional — regex fallback if not configured)
+    ▼
+PatternMatcher (interface)
+    │
+    │  match(source, language, queries): Map<string, number>
+    │  (returns match counts per query ID)
+    │
+    └── WasmPatternMatcher (now)
+          ├── Caches parser instance (reused across match() calls)
+          ├── Calls tree.delete() after each match() (WASM heap cleanup)
+          ├── Detects .tsx → returns empty map (regex fallback handles it)
+          └── Uses parseCode() + query() from scanner/tree-sitter.ts
+
+Rules are plain objects: { id: string, category: string, query: string }
+No query builder. S-expressions are string constants.
+```
 
-- [ ] **Step 1: Create error handling patterns**
+### Language routing
 
-```typescript
-// In ast-patterns.ts
-
-export interface AstPatternResult {
-  file: string;
-  matches: Array<{
-    rule: string;
-    line: number;
-    text: string;
-  }>;
-}
-
-/**
- * Run ast-grep with a pattern rule on a file. Returns matches.
- * Pure function over CLI — no state.
- */
-/**
- * Run ast-grep with a YAML rule on a file. Returns matches.
- *
- * IMPORTANT: `--rule` expects a file path, not inline YAML.
- * We write a temp file for each rule invocation.
- * Uses execFileSync (array args) to avoid shell injection via file paths.
- */
-export function runAstGrepRule(
-  filePath: string,
-  ruleYaml: string,
-  repositoryPath: string
-): AstPatternResult {
-  try {
-    const tmpRule = path.join(os.tmpdir(), `ast-grep-rule-${Date.now()}.yml`);
-    fs.writeFileSync(tmpRule, ruleYaml);
-    try {
-      const output = execFileSync(
-        'ast-grep', ['scan', '--rule', tmpRule, '--json', filePath],
-        { cwd: repositoryPath, encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'], timeout: 10000 }
-      );
-      const matches = JSON.parse(output || '[]');
-      return { file: filePath, matches };
-    } finally {
-      fs.unlinkSync(tmpRule);
-    }
-  } catch {
-    return { file: filePath, matches: [] };
-  }
-}
-
-/** Built-in rules for error handling detection */
-export const ERROR_HANDLING_RULES = {
-  tryCatch: `
-rule:
-  kind: try_statement
-`,
-  promiseCatch: `
-rule:
-  pattern: $PROMISE.catch($HANDLER)
-`,
-  throwStatement: `
-rule:
-  kind: throw_statement
-`,
-  asyncAwaitTryCatch: `
-rule:
-  kind: try_statement
-  has:
-    kind: await_expression
-`,
-};
-```
+| Extension | Grammar | Size | AST available |
+|-----------|---------|------|---------------|
+| `.ts` | tree-sitter-typescript | 2.3MB | Yes — all 10 queries |
+| `.tsx` | tree-sitter-tsx | 2.3MB | Yes — same queries (TSX is a TS superset) |
+| `.js` | tree-sitter-javascript | 647KB | Yes — 8 queries (type coverage queries return 0, correct) |
+| `.jsx` | tree-sitter-javascript | (shared) | Yes — same as `.js` |
+| `.go` | tree-sitter-go (already bundled) | 236KB | Future — no Go rules yet |
+| `.vue`, `.svelte`, `.md`, other | Not supported | — | No → regex fallback |
 
-- [ ] **Step 2: Write test for error handling detection**
+All 4 JS/TS grammars bundled. Covers the entire Node/frontend ecosystem:
+React, Next.js, Angular, NestJS, Vue (script blocks), Svelte (script blocks),
+Express, etc. Type coverage queries naturally return 0 on `.js`/`.jsx` (no type
+annotations in JS — correct behavior, not a bug).
 
-```typescript
-describe('AST error handling detection', () => {
-  // Mock execFileSync to avoid requiring ast-grep binary in CI.
-  // Tests verify parsing and classification logic, not the binary.
+Total WASM bundle: ~5.5MB (TS + TSX + JS + Go).
 
-  it('should detect try/catch blocks via mock', () => {
-    const mockOutput = JSON.stringify([{ rule: 'try_statement', line: 2, text: 'try {' }]);
-    vi.spyOn(child_process, 'execFileSync').mockReturnValue(mockOutput);
+### WASM memory management
 
-    const result = runAstGrepRule('src/test.ts', ERROR_HANDLING_RULES.tryCatch, tempDir);
-    expect(result.matches.length).toBe(1);
-    expect(result.matches[0].rule).toBe('try_statement');
+web-tree-sitter allocates `Parser` and `Tree` objects on the WASM heap. JavaScript's
+GC does not collect these — they must be explicitly `.delete()`-ed.
 
-    vi.restoreAllMocks();
-  });
+- **Parser:** Cached in `WasmPatternMatcher` instance. Created once, reused across
+  `match()` calls. Deleted when `WasmPatternMatcher` is disposed (if needed).
+- **Tree:** Created per `match()` call. Deleted in a `finally` block after queries run.
 
-  it('should detect throw statements via mock', () => {
-    const mockOutput = JSON.stringify([{ rule: 'throw_statement', line: 1, text: 'throw new Error' }]);
-    vi.spyOn(child_process, 'execFileSync').mockReturnValue(mockOutput);
+### NAPI swap path (future)
 
-    const result = runAstGrepRule('src/test.ts', ERROR_HANDLING_RULES.throwStatement, tempDir);
-    expect(result.matches.length).toBe(1);
+When/if needed:
+1. Add `NapiPatternMatcher` implementing same interface
+2. Translate our S-expressions to ast-grep patterns (or keep S-expressions — NAPI supports them)
+3. Update factory function
+4. All consumers unchanged
 
-    vi.restoreAllMocks();
-  });
+---
 
-  it('should return empty matches on failure', () => {
-    vi.spyOn(child_process, 'execFileSync').mockImplementation(() => { throw new Error('not found'); });
+## What changes
 
-    const result = runAstGrepRule('src/test.ts', ERROR_HANDLING_RULES.tryCatch, tempDir);
-    expect(result.matches.length).toBe(0);
+### New files
 
-    vi.restoreAllMocks();
-  });
+| File | What |
+|------|------|
+| `packages/core/src/pattern-matcher/index.ts` | `PatternMatcher` interface, `PatternMatchRule` type, rule constants, factory |
+| `packages/core/src/pattern-matcher/wasm-matcher.ts` | WASM implementation with cached parser + tree cleanup |
+| `packages/core/src/pattern-matcher/__tests__/wasm-matcher.test.ts` | 10 positive, 6 negative, 3 edge case, 1 perf test |
 
-  it('should detect promise.catch via mock', () => {
-    const mockOutput = JSON.stringify([{ rule: 'promiseCatch', line: 3, text: '.catch(handler)' }]);
-    vi.spyOn(child_process, 'execFileSync').mockReturnValue(mockOutput);
+### Modified files
 
-    const result = runAstGrepRule('src/test.ts', ERROR_HANDLING_RULES.promiseCatch, tempDir);
-    expect(result.matches.length).toBe(1);
+| File | What changes |
+|------|-------------|
+| `packages/core/src/scanner/tree-sitter.ts` | Add `'typescript'` to `TreeSitterLanguage` |
+| `packages/dev-agent/scripts/copy-wasm.js` | Add `'typescript'` to `SUPPORTED_LANGUAGES` |
+| `packages/core/src/services/pattern-analysis-service.ts` | AST-enhanced extractors with regex fallback |
+| `packages/core/src/services/pattern-analysis-types.ts` | Add optional `PatternMatcher` to config |
+| `packages/mcp-server/src/adapters/built-in/inspect-adapter.ts` | Pass `PatternMatcher` through |
+| `packages/mcp-server/bin/dev-agent-mcp.ts` | Wire `PatternMatcher` at startup |
 
-    vi.restoreAllMocks();
-  });
-});
-```
+---
 
-- [ ] **Step 3: Commit**
+## Tasks
 
-```bash
-git add packages/core/src/services/ast-patterns.ts packages/core/src/services/__tests__/ast-patterns.test.ts
-git commit -m "feat(core): add ast-grep based error handling detection"
-```
+### Task 1: Bundle TS/TSX/JS WASM + register languages
 
----
+- Add `'typescript' | 'tsx' | 'javascript'` to `TreeSitterLanguage` type in `scanner/tree-sitter.ts`
+- Add `'typescript'`, `'tsx'`, `'javascript'` to `SUPPORTED_LANGUAGES` in `copy-wasm.js`
+- Verify `parseCode()` works for all 3 grammars
+- Test: parse a TS, TSX, and JS file, query for `(function_declaration) @match`
+- `.jsx` routes to `'javascript'` grammar (JSX is a subset of the JS grammar)
 
-## Task 3: Integrate AST patterns into PatternAnalysisService
+**Risk:** WASM files add ~5.3MB to bundle (TS 2.3MB + TSX 2.3MB + JS 647KB).
+**Mitigation:** Acceptable for a CLI tool installed globally. `node_modules` is already
+hundreds of MB. We're not a browser bundle — install size is not a primary constraint.
 
-Replace the regex-based `extractErrorHandlingFromContent` with AST detection when ast-grep is available, falling back to regex otherwise.
+**Commit:** `feat(core): bundle tree-sitter TS/TSX/JS WASM for AST analysis`
 
-- [ ] **Step 1: Add AST-enhanced error handling analyzer**
+### Task 2: PatternMatcher interface + WASM implementation
+
+- `PatternMatcher` interface: `match(source, language, queries): Map<string, number>`
+- `PatternMatchRule` type: `{ id: string; category: string; query: string }`
+- All 10 rule constants with documented limitations in code comments
+- `WasmPatternMatcher`:
+  - Caches parser instance (created on first `match()`, reused thereafter)
+  - Calls `tree.delete()` in `finally` after running queries
+  - Routes `.ts` → `'typescript'` grammar, `.tsx` → `'tsx'` grammar
+  - Invalid query or parse failure → returns empty map (never crash)
+- `createPatternMatcher()` factory
+
+**Commit:** `feat(core): add PatternMatcher with 10 verified tree-sitter queries`
+
+### Task 3: Tests for WasmPatternMatcher
+
+**Test setup:**
+- `beforeAll`: create one `WasmPatternMatcher` instance for the suite (reuses cached parser)
+- Module-level WASM caching in `tree-sitter.ts` means init happens once per process
+- Each test is independent — inline source strings, no shared mutable state
+
+**Positive cases (10 tests — assert exact match counts):**
 
 ```typescript
-// In pattern-analysis-service.ts
-
-import { ERROR_HANDLING_RULES, hasAstGrep, runAstGrepRule } from './ast-patterns.js';
-
-/**
- * Extract error handling pattern using AST (preferred) or regex (fallback).
- */
-export function extractErrorHandling(
-  content: string,
-  filePath?: string,
-  repositoryPath?: string
-): ErrorHandlingPattern {
-  // Try AST-based detection first (more accurate)
-  if (filePath && repositoryPath && hasAstGrep()) {
-    const tryCatch = runAstGrepRule(filePath, ERROR_HANDLING_RULES.tryCatch, repositoryPath);
-    const throwStmt = runAstGrepRule(filePath, ERROR_HANDLING_RULES.throwStatement, repositoryPath);
-    const promiseCatch = runAstGrepRule(filePath, ERROR_HANDLING_RULES.promiseCatch, repositoryPath);
-
-    const counts = {
-      tryCatch: tryCatch.matches.length,
-      throw: throwStmt.matches.length,
-      promiseCatch: promiseCatch.matches.length,
-    };
-
-    const total = counts.tryCatch + counts.throw + counts.promiseCatch;
-    if (total === 0) return { style: 'unknown', examples: [] };
-
-    const activePatterns = Object.values(counts).filter((c) => c > 0).length;
-    if (activePatterns > 1) return { style: 'mixed', examples: [] };
-    if (counts.throw > 0) return { style: 'throw', examples: [] };
-    // try/catch and .catch() are both catch-based — map to 'result'
-    // (closest existing style for structured error handling)
-    if (counts.tryCatch > 0 || counts.promiseCatch > 0) return { style: 'result', examples: [] };
-
-    return { style: 'unknown', examples: [] };
-  }
-
-  // Fallback to regex
-  return extractErrorHandlingFromContent(content);
-}
+// try-catch — expect count === 1
+'try { x(); } catch (e) { }'
+
+// throw — expect count === 1
+'throw new Error("bad");'
+
+// promise-catch — expect count === 1
+'fetch("/api").catch(handleError);'
+
+// await-in-try — expect count === 1
+'async function f() { try { const x = await fetch("/api"); } catch (e) {} }'
+
+// error-class — expect count === 1
+'class HttpError extends BaseError { constructor(m: string) { super(m); } }'
+
+// dynamic-import — expect count === 1
+'const m = await import("./mod");'
+
+// re-export — expect count === 1
+'export { foo } from "./bar";'
+
+// require — expect count === 1
+'const fs = require("fs");'
+
+// arrow-return-type — expect count === 1
+'const add = (a: number, b: number): number => a + b;'
+
+// function-return-type — expect count === 1
+'function greet(name: string): string { return name; }'
 ```
 
-- [ ] **Step 2: Update analyzeFileFromIndex and analyzeFileWithDocs to use new function**
+**Negative cases (10 tests — one per query, assert count === 0):**
+
+```typescript
+// try-catch: no try/catch
+'const x = 1;'
+
+// throw: no throw
+'function safe() { return 1; }'
+
+// promise-catch: .then() but not .catch()
+'fetch("/api").then(handle);'
+
+// await-in-try: bare await (not in const/let) — documents narrowness
+'async function f() { try { await fetch("/api"); } catch (e) {} }'
+
+// error-class: class without extends
+'class AppService { run() {} }'
+
+// dynamic-import: static import only
+'import { foo } from "./bar";'
 
-Replace `extractErrorHandlingFromContent(content)` with `extractErrorHandling(content, filePath, this.config.repositoryPath)` in both methods.
+// re-export: named export without from
+'export { foo };'
 
-- [ ] **Step 3: Run tests**
+// require: ESM only
+'import fs from "fs";'
 
-Run: `pnpm build && pnpm test`
-Expected: ALL PASS (ast-grep detection used when available, regex fallback otherwise)
+// arrow-return-type: arrow without return type
+'const add = (a: number, b: number) => a + b;'
 
-- [ ] **Step 4: Commit**
+// function-return-type: function without return type
+'function greet(name: string) { return name; }'
+```
+
+**Language routing tests (3 tests):**
+- `.tsx`: use existing fixture `__fixtures__/react-component.tsx` — assert try-catch count > 0
+- `.jsx`: `'const App = () => <div/>;'` routed to `'javascript'` grammar — parses without crash
+- Unknown extension (`.py`) → returns empty map
+
+**Edge cases (3 tests):**
+- Empty source string → no matches, no crash
+- Malformed TypeScript → parser handles gracefully, no crash
+- Invalid S-expression → returns empty map (exercises try/finally cleanup)
+
+**Performance sanity (1 test — P1, soft assertion):**
+- Parse ~500-line TypeScript file + all 10 queries
+- Log timing. Assert < 500ms (generous threshold to avoid CI flakiness)
+- Catches gross regressions, not micro-benchmarking
+
+**WASM cleanup note:**
+`WasmPatternMatcher` will use `createParser()` + `parser.parse()` directly (not
+`parseCode()`) to access the raw tree for `tree.delete()` in a `finally` block.
+`parseCode()` returns a `ParsedTree` that doesn't expose the tree for cleanup.
+Cleanup is verified indirectly: malformed source exercises the finally path, and
+the performance test would show obvious memory growth if trees leaked.
+
+**Commit:** `test(core): comprehensive tests for all 10 AST patterns`
+
+### Task 4: Wire into PatternAnalysisService
+
+- Add optional `PatternMatcher` to `PatternAnalysisConfig`
+- New AST-enhanced extractors (pure functions, testable):
+  - `extractErrorHandlingWithAst(content, matcher?, language?)` → enriches regex with AST
+  - `extractImportStyleWithAst(content, matcher?, language?)` → detects dynamic imports
+  - `extractTypeCoverageWithAst(content, matcher?, language?, signatures?)` → catches arrow types
+- Replace calls in `analyzeFileFromIndex` and `analyzeFileWithDocs`
+- Wire `PatternMatcher` from MCP entry point through `InspectAdapter`
+- Map file extensions to languages: `.ts` → `'typescript'`, `.tsx` → `'tsx'`, `.js`/`.jsx` → `'javascript'`, `.go` → future, others → regex fallback
+
+Classification logic (error handling):
+- throw + try-catch → `'throw'` (try/catch is mechanism, throw is style)
+- try-catch without throw → augment regex result (if regex found Result<T>, keep it)
+- promise-catch → count as additional error handling signal
+- error-class → count as additional signal (file defines custom errors)
+- No AST matches → regex only (unchanged behavior)
+
+Classification logic (imports):
+- dynamic-import detected → counts toward ESM
+- re-export detected → counts toward ESM (confirms regex detection)
+- require detected → counts toward CJS (more precise than regex)
+
+Classification logic (type coverage):
+- arrow-return-type count + function-return-type count = AST-detected annotated functions
+- Merged with signature-based detection from indexed metadata
+- Arrow functions are the main win — regex is fragile on `(): Type => ...`
+
+**Integration tests (concrete cases):**
 
-```bash
-git add packages/core/src/services/pattern-analysis-service.ts packages/core/src/services/ast-patterns.ts
-git commit -m "feat(core): use ast-grep for pattern analysis with regex fallback"
+```typescript
+// Error handling: try/catch + throw → 'throw' (try/catch is mechanism, throw is style)
+source: 'try { validate(x); } catch (e) { throw new Error("failed"); }'
+expect: extractErrorHandlingWithAst(source, matcher, 'typescript').style === 'throw'
+
+// Error handling: Result<T> + try/catch → 'mixed' (AST adds try-catch, regex found Result)
+source: 'function f(): Result<T> { try { return ok(); } catch { return err(); } }'
+expect: extractErrorHandlingWithAst(source, matcher, 'typescript').style === 'mixed'
+
+// Error handling: only promise.catch, no throw → 'unknown' (promise.catch alone
+// doesn't map to our categories — regex didn't find throw/Result either)
+source: 'fetch("/api").catch(log);'
+expect: extractErrorHandlingWithAst(source, matcher, 'typescript').style === 'unknown'
+
+// Imports: dynamic import → counts as ESM
+source: 'import { foo } from "./bar"; const m = await import("./baz");'
+expect: extractImportStyleWithAst(source, matcher, 'typescript').style === 'esm'
+
+// Type coverage: arrow with return type detected by AST
+source: 'const add = (a: number, b: number): number => a + b;'
+signatures: []  // no indexed signatures (arrow not in index)
+expect: extractTypeCoverageWithAst(source, matcher, 'typescript', signatures).annotatedCount === 1
+
+// Regex fallback: all extractors with matcher=undefined produce identical output
+// to current behavior (regression test)
+expect: extractErrorHandlingWithAst(source, undefined, undefined) ===
+        extractErrorHandlingFromContent(source)
 ```
 
+**Risk:** Behavior change for files where AST detects patterns regex missed.
+**Mitigation:** AST only adds detection, never removes. Changes are strictly more accurate.
+
+**Commit:** `feat(core,mcp): use AST pattern matching for all 3 analysis categories`
+
+---
+
+## Decisions
+
+| Decision | Rationale | Alternatives |
+|----------|-----------|-------------|
+| tree-sitter WASM, not ast-grep | Zero new deps, already bundled, universal | ast-grep NAPI: faster but new dep + platform builds |
+| S-expression constants, not query builder | YAGNI — builder was riskiest component | Query builder: ~150 lines of template code for speculative NAPI swap |
+| PatternMatcher interface (1 method) | Minimal cost, enables NAPI swap | Direct calls: simpler but locks to WASM |
+| Cache parser, delete trees | WASM heap not GC'd by JS. Parser reuse avoids repeated init. | New parser per call: ~50ms overhead per match, slow memory leak |
+| Bundle both TS and TSX grammars | React codebases are mostly .tsx — can't skip them. Same queries work on both. | Skip TSX: saves 2.3MB but misses most files in React repos |
+| `error-class` matches any extends | Custom error hierarchies are common. `extends BaseError` matters. | `#eq? "Error"` only: misses most real error classes |
+| `await-in-try` stays narrow | Exhaustive matching requires recursive descent. Diminishing returns. | Broader query: complex, fragile, marginal value |
+| Regex fallback preserved | Not all languages supported; Result<T> is regex-only | AST-only: would lose detection for unsupported languages |
+| No new error handling categories | try/catch + throw = 'throw' style. Adding categories has ripple effects. | 'try-catch' category: more precise but changes types/formatters/tests |
+| Optional PatternMatcher in config | Tests run without it, production wires it in | Required: breaks existing tests |
+
 ---
 
-## Notes
+## Risk register
+
+| Risk | Likelihood | Impact | Mitigation |
+|------|-----------|--------|------------|
+| S-expressions wrong for some grammar versions | Low | Medium | Verified against actual grammar. Tests assert match count > 0 with real source. Pin tree-sitter-wasms version. |
+| WASM heap memory leak | Medium | Medium | `tree.delete()` in finally block. Parser cached, not recreated. |
+| Bundle size +5.3MB (TS + TSX + JS WASM) | Low | Low | CLI tool, not browser. Total ~5.5MB with Go WASM. Acceptable for global install. |
+| `await-in-try` misses bare await statements | Medium | Low | Documented limitation. Regex fallback catches throw/Result<T> regardless. |
+| `error-class` false positives (non-error extends) | Low | Low | In error-handling context, non-error classes with extends are rare. |
+| WASM init latency on first call | Low | Low | Lazy init, cached. ~50ms first call, <1ms subsequent. |
+| PatternMatcher abstraction unnecessary | Low | Low | 1 method interface, ~50 line impl. Cost is minimal. |
+| tree-sitter-typescript grammar changes | Very Low | Medium | Pin tree-sitter-wasms. Tests catch regressions. |
+
+---
+
+## Test strategy
+
+| Test | Priority | What it verifies |
+|------|----------|-----------------|
+| **Positive (10 — exact counts)** | | |
+| WasmPatternMatcher — try/catch | P0 | count === 1 |
+| WasmPatternMatcher — throw | P0 | count === 1 |
+| WasmPatternMatcher — promise.catch | P0 | count === 1 |
+| WasmPatternMatcher — await-in-try | P0 | count === 1 |
+| WasmPatternMatcher — error-class | P0 | count === 1 |
+| WasmPatternMatcher — dynamic-import | P0 | count === 1 |
+| WasmPatternMatcher — re-export | P0 | count === 1 |
+| WasmPatternMatcher — require | P0 | count === 1 |
+| WasmPatternMatcher — arrow-return-type | P0 | count === 1 |
+| WasmPatternMatcher — function-return-type | P0 | count === 1 |
+| **Negative (10 — one per query)** | | |
+| no try/catch | P0 | count === 0 |
+| no throw | P0 | count === 0 |
+| .then() not .catch() | P0 | count === 0 |
+| bare await in try (documents narrowness) | P0 | count === 0 |
+| class without extends | P0 | count === 0 |
+| static import only | P0 | count === 0 |
+| export without from | P0 | count === 0 |
+| ESM only (no require) | P0 | count === 0 |
+| arrow without return type | P0 | count === 0 |
+| function without return type | P0 | count === 0 |
+| **Language routing (3)** | | |
+| TSX: fixture react-component.tsx | P0 | try-catch count > 0 |
+| JSX: routed to javascript grammar | P0 | parses without crash |
+| Unknown extension (.py) | P0 | returns empty map |
+| **Edge cases (3)** | | |
+| Empty source | P0 | no crash, empty map |
+| Malformed source | P0 | no crash |
+| Invalid S-expression | P0 | empty map (exercises finally) |
+| **Performance (1)** | | |
+| 500-line file + 10 queries | P1 | < 500ms (soft, logged) |
+| **Integration (6)** | | |
+| try/catch + throw → 'throw' | P0 | AST + regex classification |
+| Result<T> + try/catch → 'mixed' | P0 | AST augments regex |
+| promise.catch only → 'unknown' | P0 | No category mapping |
+| dynamic import → ESM | P0 | AST enriches import style |
+| arrow return type detected | P0 | AST enriches type coverage |
+| All extractors with matcher=undefined | P0 | Identical to regex-only (regression) |
+| **Regression** | | |
+| Existing 49 tests unchanged | P0 | No behavioral change on fallback path |
+
+---
 
-- ast-grep is an **optional** dependency — all functionality works without it via regex fallback
-- `hasAstGrep()` is memoized per process — single execSync on first call
-- Uses `execFileSync` (array args) instead of `execSync` (string) to prevent shell injection via file paths
-- `--rule` requires a file path — we write temp YAML files and clean up after
-- Tests mock `execFileSync` so they run in CI without ast-grep installed
-- Future: expand AST rules for import style, type coverage, naming conventions
-- Attribution: add to ARCHITECTURE.md: "AST pattern matching inspired by [ast-grep](https://github.com/ast-grep/ast-grep)"
+## Verification checklist
+
+- [ ] `tree-sitter-typescript.wasm`, `tree-sitter-tsx.wasm`, `tree-sitter-javascript.wasm` bundled in dist
+- [ ] `parseCode('const x: number = 1;', 'typescript')` works
+- [ ] `parseCode('const App = () => <div/>;', 'tsx')` works
+- [ ] `parseCode('const x = 1;', 'javascript')` works
+- [ ] All 10 positive tests assert exact match count === 1
+- [ ] All 10 negative tests assert count === 0
+- [ ] Empty/malformed source doesn't crash
+- [ ] `tree.delete()` called after every `match()` (WASM cleanup)
+- [ ] Parser cached in WasmPatternMatcher (not recreated per call)
+- [ ] Regex fallback works when PatternMatcher not configured
+- [ ] `pnpm build && pnpm test` passes (all existing + new)
+- [ ] `dev_patterns` returns results via MCP (manual test)
+- [ ] Performance: 500-line file + 10 queries < 200ms
diff --git a/.claude/scratchpad.md b/.claude/scratchpad.md
index 8bbea4b..6d3cfb0 100644
--- a/.claude/scratchpad.md
+++ b/.claude/scratchpad.md
@@ -11,10 +11,11 @@
 ## Future Work
 
 - Antfly SDK: server-side path filter for `getDocsByFilePath` (eliminates 5k cap)
-- `dev_patterns format: "json"` for token-efficient agent output (MCP Phase 1, Part 1.4)
-- ast-grep as optional dep for pattern analysis (MCP Phase 1, Part 1.5)
 - PageRank for `dev_map` hot paths (MCP Phase 1, Part 1.6)
 - E2E tests in CI — blocked on Antfly memory requirements vs GitHub runner limits (7GB)
+- **Python language support** — tree-sitter-python WASM is ~300KB, already in tree-sitter-wasms. Needs a Python scanner (document extraction) + Python-specific pattern rules. High demand — large ecosystem. Worth a standalone plan covering: scanner, pattern rules, test fixtures, indexer integration. The PatternMatcher interface from 1.5 is language-agnostic so pattern rules slot right in; the scanner is the real work.
+- 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.
 
 ## Notes
 

From 79c04af490733b62f26b77154232c1bcd20a3e0d Mon Sep 17 00:00:00 2001
From: prosdev <prosdevlab@gmail.com>
Date: Tue, 31 Mar 2026 02:36:00 -0700
Subject: [PATCH 2/8] feat(core): bundle tree-sitter TS/TSX/JS WASM for AST
 pattern analysis

Add typescript, tsx, and javascript to TreeSitterLanguage type and
SUPPORTED_LANGUAGES. Covers the full Node/frontend ecosystem:
.ts, .tsx, .js, .jsx files.

Bundle size: +5.3MB WASM (TS 2.3MB + TSX 2.3MB + JS 647KB).

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---
 packages/core/src/scanner/tree-sitter.ts | 6 ++++--
 packages/dev-agent/scripts/copy-wasm.js  | 2 +-
 2 files changed, 5 insertions(+), 3 deletions(-)

diff --git a/packages/core/src/scanner/tree-sitter.ts b/packages/core/src/scanner/tree-sitter.ts
index 49f7dae..65515c6 100644
--- a/packages/core/src/scanner/tree-sitter.ts
+++ b/packages/core/src/scanner/tree-sitter.ts
@@ -28,14 +28,16 @@ let parserInitialized = false;
  *
  * Currently supported:
  * - 'go': Go language parsing (bundled in production)
+ * - 'typescript': TypeScript parsing (for AST pattern analysis)
+ * - 'tsx': TSX parsing (TypeScript + JSX, for React codebases)
+ * - 'javascript': JavaScript/JSX parsing (for JS codebases)
  *
  * To add new languages:
  * 1. Add language to this type definition
  * 2. Update SUPPORTED_LANGUAGES in packages/dev-agent/scripts/copy-wasm.js
  * 3. Ensure tree-sitter-wasms contains the required WASM file
- * 4. Add language-specific scanner in packages/core/src/scanner/
  */
-export type TreeSitterLanguage = 'go';
+export type TreeSitterLanguage = 'go' | 'typescript' | 'tsx' | 'javascript';
 
 /**
  * Cache of loaded language grammars
diff --git a/packages/dev-agent/scripts/copy-wasm.js b/packages/dev-agent/scripts/copy-wasm.js
index 780a055..4825d28 100644
--- a/packages/dev-agent/scripts/copy-wasm.js
+++ b/packages/dev-agent/scripts/copy-wasm.js
@@ -95,7 +95,7 @@ if (!fs.existsSync(wasmSourceDir)) {
 // 3. Ensure tree-sitter-wasms package contains tree-sitter-{lang}.wasm
 // 4. Create a language-specific scanner in packages/core/src/scanner/{lang}.ts
 // 5. Update scanner registration in packages/core/src/scanner/index.ts
-const SUPPORTED_LANGUAGES = ['go'];
+const SUPPORTED_LANGUAGES = ['go', 'typescript', 'tsx', 'javascript'];
 const SUPPORTED_FILES = new Set([
   ...SUPPORTED_LANGUAGES.map((lang) => `tree-sitter-${lang}.wasm`),
   'tree-sitter.wasm', // Runtime if present

From d513b911a4776dfbe9ef0d22956bb7542ed3ffb8 Mon Sep 17 00:00:00 2001
From: prosdev <prosdevlab@gmail.com>
Date: Tue, 31 Mar 2026 02:38:26 -0700
Subject: [PATCH 3/8] feat(core): add PatternMatcher with 10 verified
 tree-sitter queries

PatternMatcher interface with WasmPatternMatcher implementation:
- 5 error handling queries (try-catch, throw, promise.catch, await-in-try, error-class)
- 3 import style queries (dynamic-import, re-export, require)
- 2 type coverage queries (arrow-return-type, function-return-type)

All S-expressions verified against actual tree-sitter-typescript grammar.
runQueries() handles parser creation, tree.delete() cleanup, and error recovery.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---
 packages/core/src/pattern-matcher/index.ts    |  19 ++++
 packages/core/src/pattern-matcher/rules.ts    | 103 ++++++++++++++++++
 .../core/src/pattern-matcher/wasm-matcher.ts  |  80 ++++++++++++++
 packages/core/src/scanner/tree-sitter.ts      |  47 ++++++++
 4 files changed, 249 insertions(+)
 create mode 100644 packages/core/src/pattern-matcher/index.ts
 create mode 100644 packages/core/src/pattern-matcher/rules.ts
 create mode 100644 packages/core/src/pattern-matcher/wasm-matcher.ts

diff --git a/packages/core/src/pattern-matcher/index.ts b/packages/core/src/pattern-matcher/index.ts
new file mode 100644
index 0000000..47bcf5c
--- /dev/null
+++ b/packages/core/src/pattern-matcher/index.ts
@@ -0,0 +1,19 @@
+/**
+ * Pattern Matcher — AST-based pattern detection via tree-sitter queries.
+ *
+ * Provides a runtime-agnostic interface for structural code pattern matching.
+ * Current implementation uses web-tree-sitter (WASM). Designed for future
+ * swap to @ast-grep/napi (native Rust) if performance requires it.
+ */
+
+export {
+  ALL_QUERIES,
+  ERROR_HANDLING_QUERIES,
+  IMPORT_STYLE_QUERIES,
+  TYPE_COVERAGE_QUERIES,
+} from './rules.js';
+export {
+  createPatternMatcher,
+  type PatternMatcher,
+  type PatternMatchRule,
+} from './wasm-matcher.js';
diff --git a/packages/core/src/pattern-matcher/rules.ts b/packages/core/src/pattern-matcher/rules.ts
new file mode 100644
index 0000000..4d945c6
--- /dev/null
+++ b/packages/core/src/pattern-matcher/rules.ts
@@ -0,0 +1,103 @@
+/**
+ * AST Pattern Rules — verified S-expression queries for tree-sitter.
+ *
+ * All queries validated against web-tree-sitter@0.25.10 + tree-sitter-wasms@0.1.13
+ * by parsing real TypeScript/JavaScript snippets and inspecting AST output.
+ *
+ * These are string constants, not a DSL. If we ever swap to @ast-grep/napi,
+ * add a translation layer at that time (YAGNI).
+ */
+
+import type { PatternMatchRule } from './wasm-matcher.js';
+
+// ============================================================================
+// Error Handling (5 rules)
+// ============================================================================
+
+export const ERROR_HANDLING_QUERIES: PatternMatchRule[] = [
+  {
+    id: 'try-catch',
+    category: 'error-handling',
+    query: '(try_statement) @match',
+  },
+  {
+    id: 'throw',
+    category: 'error-handling',
+    query: '(throw_statement) @match',
+  },
+  {
+    id: 'promise-catch',
+    category: 'error-handling',
+    query:
+      '(call_expression function: (member_expression property: (property_identifier) @method (#eq? @method "catch"))) @match',
+  },
+  {
+    // Intentionally narrow: only catches const/let declarations with await
+    // inside try blocks. Does NOT catch bare `await foo()` as expression
+    // statements or await nested inside if/for within try.
+    id: 'await-in-try',
+    category: 'error-handling',
+    query:
+      '(try_statement body: (statement_block (lexical_declaration (variable_declarator value: (await_expression))))) @match',
+  },
+  {
+    // Matches any class with an extends clause — catches custom error
+    // hierarchies (extends BaseError, extends HttpError, etc.), not just
+    // direct `extends Error`. May have false positives for non-error classes
+    // with extends, but these are rare in error-handling analysis context.
+    id: 'error-class',
+    category: 'error-handling',
+    query: '(class_declaration (class_heritage (extends_clause))) @match',
+  },
+];
+
+// ============================================================================
+// Import Style (3 rules)
+// ============================================================================
+
+export const IMPORT_STYLE_QUERIES: PatternMatchRule[] = [
+  {
+    id: 'dynamic-import',
+    category: 'import-style',
+    query: '(call_expression function: (import)) @match',
+  },
+  {
+    id: 're-export',
+    category: 'import-style',
+    query: '(export_statement source: (string)) @match',
+  },
+  {
+    id: 'require',
+    category: 'import-style',
+    query: '(call_expression function: (identifier) @fn (#eq? @fn "require")) @match',
+  },
+];
+
+// ============================================================================
+// Type Coverage (2 rules)
+// ============================================================================
+
+export const TYPE_COVERAGE_QUERIES: PatternMatchRule[] = [
+  {
+    // Arrow functions with return type — the main win over regex.
+    // Regex is fragile on `(a: number, b: number): number => ...`
+    id: 'arrow-return-type',
+    category: 'type-coverage',
+    query: '(arrow_function return_type: (type_annotation)) @match',
+  },
+  {
+    id: 'function-return-type',
+    category: 'type-coverage',
+    query: '(function_declaration return_type: (type_annotation)) @match',
+  },
+];
+
+// ============================================================================
+// All rules combined
+// ============================================================================
+
+export const ALL_QUERIES: PatternMatchRule[] = [
+  ...ERROR_HANDLING_QUERIES,
+  ...IMPORT_STYLE_QUERIES,
+  ...TYPE_COVERAGE_QUERIES,
+];
diff --git a/packages/core/src/pattern-matcher/wasm-matcher.ts b/packages/core/src/pattern-matcher/wasm-matcher.ts
new file mode 100644
index 0000000..bb8489a
--- /dev/null
+++ b/packages/core/src/pattern-matcher/wasm-matcher.ts
@@ -0,0 +1,80 @@
+/**
+ * WASM Pattern Matcher — tree-sitter query-based pattern detection.
+ *
+ * Uses web-tree-sitter (WASM) to parse source code and run S-expression
+ * queries. Handles tree cleanup (WASM heap is not GC'd by JS).
+ *
+ * Designed for future swap to @ast-grep/napi — the PatternMatcher interface
+ * is runtime-agnostic.
+ */
+
+import type { TreeSitterLanguage } from '../scanner/tree-sitter.js';
+import { runQueries } from '../scanner/tree-sitter.js';
+
+/**
+ * A pattern rule — S-expression query with metadata.
+ */
+export interface PatternMatchRule {
+  id: string;
+  category: string;
+  query: string;
+}
+
+/**
+ * Runtime-agnostic pattern matcher interface.
+ * Returns match counts per query ID.
+ */
+export interface PatternMatcher {
+  match(
+    source: string,
+    language: string,
+    queries: PatternMatchRule[]
+  ): Promise<Map<string, number>>;
+}
+
+/**
+ * File extension → tree-sitter language mapping.
+ */
+const EXTENSION_TO_LANGUAGE: Record<string, TreeSitterLanguage> = {
+  '.ts': 'typescript',
+  '.tsx': 'tsx',
+  '.js': 'javascript',
+  '.jsx': 'javascript',
+};
+
+/**
+ * Resolve a file extension to a tree-sitter language.
+ * Returns undefined for unsupported extensions.
+ */
+export function resolveLanguage(filePath: string): TreeSitterLanguage | undefined {
+  const ext = `.${filePath.split('.').pop()?.toLowerCase() ?? ''}`;
+  return EXTENSION_TO_LANGUAGE[ext];
+}
+
+/**
+ * WASM-based PatternMatcher using web-tree-sitter.
+ */
+class WasmPatternMatcher implements PatternMatcher {
+  async match(
+    source: string,
+    language: string,
+    queries: PatternMatchRule[]
+  ): Promise<Map<string, number>> {
+    // Validate language is supported
+    const supportedLanguages = new Set<string>(['typescript', 'tsx', 'javascript', 'go']);
+    if (!supportedLanguages.has(language)) {
+      return new Map();
+    }
+
+    return runQueries(source, language as TreeSitterLanguage, queries);
+  }
+}
+
+/**
+ * Create a PatternMatcher instance.
+ * Currently returns WasmPatternMatcher. Future: could return NapiPatternMatcher
+ * based on availability.
+ */
+export function createPatternMatcher(): PatternMatcher {
+  return new WasmPatternMatcher();
+}
diff --git a/packages/core/src/scanner/tree-sitter.ts b/packages/core/src/scanner/tree-sitter.ts
index 65515c6..83a4448 100644
--- a/packages/core/src/scanner/tree-sitter.ts
+++ b/packages/core/src/scanner/tree-sitter.ts
@@ -337,6 +337,53 @@ export async function parseCode(
   }
 }
 
+/**
+ * Parse source and run multiple S-expression queries, returning match counts.
+ * Handles parser creation, tree cleanup (WASM heap), and error recovery.
+ *
+ * Used by PatternMatcher for AST-based pattern detection.
+ */
+export async function runQueries(
+  sourceText: string,
+  language: TreeSitterLanguage,
+  queries: Array<{ id: string; query: string }>
+): Promise<Map<string, number>> {
+  const results = new Map<string, number>();
+  if (!sourceText.trim()) return results;
+
+  await initTreeSitter();
+  if (!ParserClass || !QueryClass) return results;
+
+  const parser = new ParserClass();
+  let tree: ReturnType<typeof parser.parse> | null = null;
+
+  try {
+    const lang = await loadLanguage(language);
+    parser.setLanguage(lang);
+    tree = parser.parse(sourceText);
+    if (!tree) return results;
+
+    const QueryCls = QueryClass;
+    for (const { id, query: queryString } of queries) {
+      try {
+        const q = new QueryCls(lang, queryString);
+        const matches = q.matches(tree.rootNode);
+        results.set(id, matches.length);
+      } catch {
+        // Invalid query — skip, return 0 for this rule
+        results.set(id, 0);
+      }
+    }
+  } catch {
+    // Parse failure — return empty results
+  } finally {
+    tree?.delete();
+    parser.delete();
+  }
+
+  return results;
+}
+
 /**
  * Helper to get text from source by line numbers (1-based)
  */

From 6f69c871a624313990190ac5e830baf32ab9317f Mon Sep 17 00:00:00 2001
From: prosdev <prosdevlab@gmail.com>
Date: Tue, 31 Mar 2026 02:39:49 -0700
Subject: [PATCH 4/8] test(core): comprehensive tests for all 10 AST patterns
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

10 positive (exact counts), 10 negative (one per query), 3 language
routing (TSX fixture, JSX→javascript, unsupported), 3 edge cases
(empty, malformed, invalid query), 1 performance sanity (552 lines
+ 10 queries in 35ms), 5 resolveLanguage extension tests.

32 tests total. All S-expressions verified against real tree-sitter
parsing — no mocks.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---
 .../__tests__/wasm-matcher.test.ts            | 345 ++++++++++++++++++
 1 file changed, 345 insertions(+)
 create mode 100644 packages/core/src/pattern-matcher/__tests__/wasm-matcher.test.ts

diff --git a/packages/core/src/pattern-matcher/__tests__/wasm-matcher.test.ts b/packages/core/src/pattern-matcher/__tests__/wasm-matcher.test.ts
new file mode 100644
index 0000000..2fd8429
--- /dev/null
+++ b/packages/core/src/pattern-matcher/__tests__/wasm-matcher.test.ts
@@ -0,0 +1,345 @@
+/**
+ * WasmPatternMatcher Tests
+ *
+ * Tests AST-based pattern detection using real tree-sitter parsing.
+ * 10 positive (exact counts), 10 negative (count === 0), 3 routing,
+ * 3 edge cases, 1 performance sanity check.
+ */
+
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import { beforeAll, describe, expect, it } from 'vitest';
+import {
+  ALL_QUERIES,
+  ERROR_HANDLING_QUERIES,
+  IMPORT_STYLE_QUERIES,
+  TYPE_COVERAGE_QUERIES,
+} from '../rules';
+import { createPatternMatcher, type PatternMatcher, resolveLanguage } from '../wasm-matcher';
+
+describe('WasmPatternMatcher', () => {
+  let matcher: PatternMatcher;
+
+  beforeAll(() => {
+    matcher = createPatternMatcher();
+  });
+
+  // ========================================================================
+  // Positive cases (10 tests — assert exact match counts)
+  // ========================================================================
+
+  describe('positive matches (exact counts)', () => {
+    it('detects try/catch — count === 1', async () => {
+      const results = await matcher.match(
+        'try { x(); } catch (e) { }',
+        'typescript',
+        ERROR_HANDLING_QUERIES
+      );
+      expect(results.get('try-catch')).toBe(1);
+    });
+
+    it('detects throw — count === 1', async () => {
+      const results = await matcher.match(
+        'throw new Error("bad");',
+        'typescript',
+        ERROR_HANDLING_QUERIES
+      );
+      expect(results.get('throw')).toBe(1);
+    });
+
+    it('detects promise.catch — count === 1', async () => {
+      const results = await matcher.match(
+        'fetch("/api").catch(handleError);',
+        'typescript',
+        ERROR_HANDLING_QUERIES
+      );
+      expect(results.get('promise-catch')).toBe(1);
+    });
+
+    it('detects await-in-try (const declaration) — count === 1', async () => {
+      const results = await matcher.match(
+        'async function f() { try { const x = await fetch("/api"); } catch (e) {} }',
+        'typescript',
+        ERROR_HANDLING_QUERIES
+      );
+      expect(results.get('await-in-try')).toBe(1);
+    });
+
+    it('detects error-class with extends — count === 1', async () => {
+      const results = await matcher.match(
+        'class HttpError extends BaseError { constructor(m: string) { super(m); } }',
+        'typescript',
+        ERROR_HANDLING_QUERIES
+      );
+      expect(results.get('error-class')).toBe(1);
+    });
+
+    it('detects dynamic import — count === 1', async () => {
+      const results = await matcher.match(
+        'const m = await import("./mod");',
+        'typescript',
+        IMPORT_STYLE_QUERIES
+      );
+      expect(results.get('dynamic-import')).toBe(1);
+    });
+
+    it('detects re-export — count === 1', async () => {
+      const results = await matcher.match(
+        'export { foo } from "./bar";',
+        'typescript',
+        IMPORT_STYLE_QUERIES
+      );
+      expect(results.get('re-export')).toBe(1);
+    });
+
+    it('detects require — count === 1', async () => {
+      const results = await matcher.match(
+        'const fs = require("fs");',
+        'typescript',
+        IMPORT_STYLE_QUERIES
+      );
+      expect(results.get('require')).toBe(1);
+    });
+
+    it('detects arrow function return type — count === 1', async () => {
+      const results = await matcher.match(
+        'const add = (a: number, b: number): number => a + b;',
+        'typescript',
+        TYPE_COVERAGE_QUERIES
+      );
+      expect(results.get('arrow-return-type')).toBe(1);
+    });
+
+    it('detects function return type — count === 1', async () => {
+      const results = await matcher.match(
+        'function greet(name: string): string { return name; }',
+        'typescript',
+        TYPE_COVERAGE_QUERIES
+      );
+      expect(results.get('function-return-type')).toBe(1);
+    });
+  });
+
+  // ========================================================================
+  // Negative cases (10 tests — one per query, count === 0)
+  // ========================================================================
+
+  describe('negative matches (count === 0)', () => {
+    it('no try/catch in source', async () => {
+      const results = await matcher.match('const x = 1;', 'typescript', ERROR_HANDLING_QUERIES);
+      expect(results.get('try-catch')).toBe(0);
+    });
+
+    it('no throw in source', async () => {
+      const results = await matcher.match(
+        'function safe() { return 1; }',
+        'typescript',
+        ERROR_HANDLING_QUERIES
+      );
+      expect(results.get('throw')).toBe(0);
+    });
+
+    it('.then() but not .catch()', async () => {
+      const results = await matcher.match(
+        'fetch("/api").then(handle);',
+        'typescript',
+        ERROR_HANDLING_QUERIES
+      );
+      expect(results.get('promise-catch')).toBe(0);
+    });
+
+    it('bare await in try — documents narrowness', async () => {
+      // await-in-try only matches const/let declarations with await.
+      // Bare await as expression statement is intentionally not matched.
+      const results = await matcher.match(
+        'async function f() { try { await fetch("/api"); } catch (e) {} }',
+        'typescript',
+        ERROR_HANDLING_QUERIES
+      );
+      expect(results.get('await-in-try')).toBe(0);
+    });
+
+    it('class without extends', async () => {
+      const results = await matcher.match(
+        'class AppService { run() {} }',
+        'typescript',
+        ERROR_HANDLING_QUERIES
+      );
+      expect(results.get('error-class')).toBe(0);
+    });
+
+    it('static import only — no dynamic import', async () => {
+      const results = await matcher.match(
+        'import { foo } from "./bar";',
+        'typescript',
+        IMPORT_STYLE_QUERIES
+      );
+      expect(results.get('dynamic-import')).toBe(0);
+    });
+
+    it('named export without from — not a re-export', async () => {
+      const results = await matcher.match('export { foo };', 'typescript', IMPORT_STYLE_QUERIES);
+      expect(results.get('re-export')).toBe(0);
+    });
+
+    it('ESM only — no require', async () => {
+      const results = await matcher.match(
+        'import fs from "fs";',
+        'typescript',
+        IMPORT_STYLE_QUERIES
+      );
+      expect(results.get('require')).toBe(0);
+    });
+
+    it('arrow without return type', async () => {
+      const results = await matcher.match(
+        'const add = (a: number, b: number) => a + b;',
+        'typescript',
+        TYPE_COVERAGE_QUERIES
+      );
+      expect(results.get('arrow-return-type')).toBe(0);
+    });
+
+    it('function without return type', async () => {
+      const results = await matcher.match(
+        'function greet(name: string) { return name; }',
+        'typescript',
+        TYPE_COVERAGE_QUERIES
+      );
+      expect(results.get('function-return-type')).toBe(0);
+    });
+  });
+
+  // ========================================================================
+  // Language routing (3 tests)
+  // ========================================================================
+
+  describe('language routing', () => {
+    it('parses TSX with try/catch in JSX component', async () => {
+      // Use the real fixture file for realistic TSX
+      const fixturePath = path.join(__dirname, '../../services/__fixtures__/react-component.tsx');
+      let source: string;
+      try {
+        source = await fs.readFile(fixturePath, 'utf-8');
+      } catch {
+        // Fixture not available — use inline TSX
+        source = `
+function App() {
+  try { const data = JSON.parse("{}"); } catch (e) { console.error(e); }
+  return <div>hello</div>;
+}`;
+      }
+
+      const results = await matcher.match(source, 'tsx', ERROR_HANDLING_QUERIES);
+      expect(results.get('try-catch')).toBeGreaterThan(0);
+    });
+
+    it('routes .jsx to javascript grammar', async () => {
+      const results = await matcher.match(
+        'const App = () => { try { x(); } catch (e) {} return null; };',
+        'javascript',
+        ERROR_HANDLING_QUERIES
+      );
+      expect(results.get('try-catch')).toBe(1);
+    });
+
+    it('returns empty map for unsupported language', async () => {
+      const results = await matcher.match('def hello(): pass', 'python', ERROR_HANDLING_QUERIES);
+      expect(results.size).toBe(0);
+    });
+  });
+
+  // ========================================================================
+  // Edge cases (3 tests)
+  // ========================================================================
+
+  describe('edge cases', () => {
+    it('empty source — no matches, no crash', async () => {
+      const results = await matcher.match('', 'typescript', ALL_QUERIES);
+      // Empty source returns empty map (short-circuits before parsing)
+      expect(results.size).toBe(0);
+    });
+
+    it('malformed TypeScript — no crash', async () => {
+      const results = await matcher.match(
+        'function { { { const = ;; }}',
+        'typescript',
+        ERROR_HANDLING_QUERIES
+      );
+      // Parser handles gracefully — may return partial results or empty
+      expect(results).toBeInstanceOf(Map);
+    });
+
+    it('invalid S-expression — returns 0 for that query', async () => {
+      const badRule = [{ id: 'bad', category: 'test', query: '(((invalid_garbage @@@' }];
+      const results = await matcher.match('const x = 1;', 'typescript', badRule);
+      expect(results.get('bad')).toBe(0);
+    });
+  });
+
+  // ========================================================================
+  // Performance sanity (1 test — soft assertion)
+  // ========================================================================
+
+  describe('performance', () => {
+    it('parses ~500 lines + 10 queries in reasonable time', async () => {
+      // Generate a realistic ~500-line TypeScript file
+      const lines: string[] = ['import { foo } from "./bar";', ''];
+      for (let i = 0; i < 50; i++) {
+        lines.push(`export function fn${i}(x: number): number {`);
+        lines.push('  try {');
+        lines.push(`    const result = await fetch("/api/${i}");`);
+        lines.push('    if (!result.ok) throw new Error("failed");');
+        lines.push('    return result.json();');
+        lines.push('  } catch (e) {');
+        lines.push('    console.error(e);');
+        lines.push('    throw e;');
+        lines.push('  }');
+        lines.push('}');
+        lines.push('');
+      }
+      const source = lines.join('\n');
+
+      const start = Date.now();
+      const results = await matcher.match(source, 'typescript', ALL_QUERIES);
+      const duration = Date.now() - start;
+
+      // Soft assertion — log timing, generous threshold
+      console.log(`Performance: ${source.split('\n').length} lines, 10 queries, ${duration}ms`);
+      expect(duration).toBeLessThan(500);
+
+      // Sanity: should find patterns in the generated code
+      expect(results.get('try-catch')).toBeGreaterThan(0);
+      expect(results.get('throw')).toBeGreaterThan(0);
+      expect(results.get('function-return-type')).toBeGreaterThan(0);
+    });
+  });
+});
+
+// ========================================================================
+// resolveLanguage (extension routing)
+// ========================================================================
+
+describe('resolveLanguage', () => {
+  it('maps .ts to typescript', () => {
+    expect(resolveLanguage('src/auth.ts')).toBe('typescript');
+  });
+
+  it('maps .tsx to tsx', () => {
+    expect(resolveLanguage('components/App.tsx')).toBe('tsx');
+  });
+
+  it('maps .js to javascript', () => {
+    expect(resolveLanguage('lib/utils.js')).toBe('javascript');
+  });
+
+  it('maps .jsx to javascript', () => {
+    expect(resolveLanguage('components/App.jsx')).toBe('javascript');
+  });
+
+  it('returns undefined for unsupported extensions', () => {
+    expect(resolveLanguage('main.py')).toBeUndefined();
+    expect(resolveLanguage('main.go')).toBeUndefined(); // Go has scanner, not pattern matcher
+    expect(resolveLanguage('README.md')).toBeUndefined();
+  });
+});

From d0825517a6c2abb91568ee34656ff7adb527a434 Mon Sep 17 00:00:00 2001
From: prosdev <prosdevlab@gmail.com>
Date: Tue, 31 Mar 2026 02:43:49 -0700
Subject: [PATCH 5/8] feat(core,mcp): use AST pattern matching for all 3
 analysis categories

Wire PatternMatcher through InspectAdapter to PatternAnalysisService.
Three AST-enhanced extractors with regex fallback:
- extractErrorHandlingWithAst: detects try/catch, promise.catch, error classes
- extractImportStyleWithAst: detects dynamic imports, precise require
- extractTypeCoverageWithAst: detects arrow function return types

All extractors fall back to regex when PatternMatcher is not configured
or file extension is unsupported. Existing 49 tests pass unchanged.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---
 packages/core/src/index.ts                    |   1 +
 .../src/services/pattern-analysis-service.ts  | 146 +++++++++++++++++-
 .../src/services/pattern-analysis-types.ts    |   1 +
 packages/mcp-server/bin/dev-agent-mcp.ts      |   2 +
 .../src/adapters/built-in/inspect-adapter.ts  |   3 +
 5 files changed, 147 insertions(+), 6 deletions(-)

diff --git a/packages/core/src/index.ts b/packages/core/src/index.ts
index 72386ff..4cd0012 100644
--- a/packages/core/src/index.ts
+++ b/packages/core/src/index.ts
@@ -6,6 +6,7 @@ export * from './events';
 export * from './indexer';
 export * from './map';
 export * from './observability';
+export { createPatternMatcher, type PatternMatcher } from './pattern-matcher';
 export * from './scanner';
 export * from './services';
 export * from './storage';
diff --git a/packages/core/src/services/pattern-analysis-service.ts b/packages/core/src/services/pattern-analysis-service.ts
index e85b6d4..943c780 100644
--- a/packages/core/src/services/pattern-analysis-service.ts
+++ b/packages/core/src/services/pattern-analysis-service.ts
@@ -7,6 +7,13 @@
 
 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 { resolveLanguage } from '../pattern-matcher/wasm-matcher';
 import { scanRepository } from '../scanner';
 import type { Document } from '../scanner/types';
 import { findTestFile, isTestFile } from '../utils/test-utils';
@@ -102,6 +109,121 @@ export function extractTypeCoverageFromSignatures(signatures: string[]): TypeAnn
   return { coverage, annotatedCount: annotated.length, totalCount: signatures.length };
 }
 
+// ========================================================================
+// AST-Enhanced Extractors — use PatternMatcher when available, regex fallback
+// ========================================================================
+
+/**
+ * Run AST queries if matcher and language are available, else return empty map.
+ */
+async function runAstQueries(
+  content: string,
+  filePath: string | undefined,
+  matcher: PatternMatcher | undefined,
+  queries: PatternMatchRule[]
+): 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);
+}
+
+/**
+ * Extract error handling using AST (preferred) + regex (fallback/supplement).
+ */
+export async function extractErrorHandlingWithAst(
+  content: string,
+  filePath?: string,
+  matcher?: PatternMatcher
+): Promise<ErrorHandlingPattern> {
+  const regex = extractErrorHandlingFromContent(content);
+  const ast = await runAstQueries(content, filePath, matcher, ERROR_HANDLING_QUERIES);
+
+  if (ast.size === 0) return regex;
+
+  const hasThrow = (ast.get('throw') ?? 0) > 0;
+  const hasTryCatch = (ast.get('try-catch') ?? 0) > 0;
+  const hasPromiseCatch = (ast.get('promise-catch') ?? 0) > 0;
+  const hasResultRegex = regex.style === 'result';
+
+  // Classification: throw is the style, try-catch is the mechanism
+  if (hasThrow && (hasTryCatch || hasPromiseCatch || hasResultRegex)) {
+    return { style: 'mixed', examples: [] };
+  }
+  if (hasThrow) return { style: 'throw', examples: [] };
+  if (hasResultRegex) return regex; // AST can't detect Result<T>, keep regex
+  if (hasTryCatch || hasPromiseCatch) return { style: 'throw', examples: [] };
+
+  return regex;
+}
+
+/**
+ * Extract import style using AST (preferred) + regex (fallback/supplement).
+ */
+export async function extractImportStyleWithAst(
+  content: string,
+  filePath?: string,
+  matcher?: PatternMatcher
+): Promise<ImportStylePattern> {
+  const regex = extractImportStyleFromContent(content);
+  const ast = await runAstQueries(content, filePath, matcher, IMPORT_STYLE_QUERIES);
+
+  if (ast.size === 0) return regex;
+
+  const dynamicImports = ast.get('dynamic-import') ?? 0;
+  const reExports = ast.get('re-export') ?? 0;
+  const requires = ast.get('require') ?? 0;
+
+  // Dynamic imports count as ESM
+  const esmCount =
+    (regex.style === 'esm' || regex.style === 'mixed' ? regex.importCount : 0) +
+    dynamicImports +
+    reExports;
+  const cjsCount = requires;
+
+  if (esmCount === 0 && cjsCount === 0) return regex;
+
+  const hasESM = esmCount > 0 || regex.style === 'esm' || regex.style === 'mixed';
+  const hasCJS = cjsCount > 0 || regex.style === 'cjs' || regex.style === 'mixed';
+  const style: ImportStylePattern['style'] = hasESM && hasCJS ? 'mixed' : hasESM ? 'esm' : 'cjs';
+  return { style, importCount: regex.importCount + dynamicImports };
+}
+
+/**
+ * Extract type coverage using AST (preferred) + regex signatures (supplement).
+ */
+export async function extractTypeCoverageWithAst(
+  content: string,
+  filePath?: string,
+  matcher?: PatternMatcher,
+  signatures?: string[]
+): Promise<TypeAnnotationPattern> {
+  // Start with signature-based detection (from index or ts-morph)
+  const regex = extractTypeCoverageFromSignatures(signatures ?? []);
+  const ast = await runAstQueries(content, filePath, matcher, TYPE_COVERAGE_QUERIES);
+
+  if (ast.size === 0) return regex;
+
+  const arrowTyped = ast.get('arrow-return-type') ?? 0;
+  const functionTyped = ast.get('function-return-type') ?? 0;
+  const astAnnotated = arrowTyped + functionTyped;
+
+  // Merge: use the higher count (AST catches arrows that signatures miss)
+  const annotatedCount = Math.max(regex.annotatedCount, astAnnotated);
+  const totalCount = Math.max(regex.totalCount, astAnnotated); // at least as many as annotated
+
+  if (totalCount === 0) return regex;
+
+  const ratio = annotatedCount / totalCount;
+  let coverage: TypeAnnotationPattern['coverage'];
+  if (ratio >= 0.9) coverage = 'full';
+  else if (ratio >= 0.5) coverage = 'partial';
+  else if (ratio > 0) coverage = 'minimal';
+  else coverage = 'none';
+
+  return { coverage, annotatedCount, totalCount };
+}
+
 /**
  * Pattern Analysis Service
  *
@@ -160,12 +282,18 @@ 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),
+    ]);
+
     return {
       fileSize: { lines, bytes },
       testing,
-      importStyle: extractImportStyleFromContent(content),
-      errorHandling: extractErrorHandlingFromContent(content),
-      typeAnnotations: extractTypeCoverageFromSignatures(signatures),
+      importStyle,
+      errorHandling,
+      typeAnnotations,
     };
   }
 
@@ -256,12 +384,18 @@ 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),
+    ]);
+
     return {
       fileSize: { lines: content.split('\n').length, bytes: stat.size },
       testing,
-      importStyle: extractImportStyleFromContent(content),
-      errorHandling: extractErrorHandlingFromContent(content),
-      typeAnnotations: extractTypeCoverageFromSignatures(signatures),
+      importStyle,
+      errorHandling,
+      typeAnnotations,
     };
   }
 
diff --git a/packages/core/src/services/pattern-analysis-types.ts b/packages/core/src/services/pattern-analysis-types.ts
index e035275..e0e3c3e 100644
--- a/packages/core/src/services/pattern-analysis-types.ts
+++ b/packages/core/src/services/pattern-analysis-types.ts
@@ -123,4 +123,5 @@ export interface PatternComparison {
 export interface PatternAnalysisConfig {
   repositoryPath: string;
   vectorStorage?: import('../vector/index.js').VectorStorage;
+  patternMatcher?: import('../pattern-matcher/wasm-matcher.js').PatternMatcher;
 }
diff --git a/packages/mcp-server/bin/dev-agent-mcp.ts b/packages/mcp-server/bin/dev-agent-mcp.ts
index a252e7a..5b5fe16 100644
--- a/packages/mcp-server/bin/dev-agent-mcp.ts
+++ b/packages/mcp-server/bin/dev-agent-mcp.ts
@@ -5,6 +5,7 @@
  */
 
 import {
+  createPatternMatcher,
   ensureStorageDirectory,
   getStorageFilePaths,
   getStoragePath,
@@ -268,6 +269,7 @@ async function main() {
       repositoryPath,
       searchService,
       vectorStorage: indexer.getVectorStorage(),
+      patternMatcher: createPatternMatcher(),
       defaultLimit: 10,
       defaultThreshold: 0.7,
       defaultFormat: 'compact',
diff --git a/packages/mcp-server/src/adapters/built-in/inspect-adapter.ts b/packages/mcp-server/src/adapters/built-in/inspect-adapter.ts
index f33553d..02a16b1 100644
--- a/packages/mcp-server/src/adapters/built-in/inspect-adapter.ts
+++ b/packages/mcp-server/src/adapters/built-in/inspect-adapter.ts
@@ -8,6 +8,7 @@
 import {
   PatternAnalysisService,
   type PatternComparison,
+  type PatternMatcher,
   type SearchService,
   type VectorStorage,
 } from '@prosdevlab/dev-agent-core';
@@ -20,6 +21,7 @@ export interface InspectAdapterConfig {
   repositoryPath: string;
   searchService: SearchService;
   vectorStorage?: VectorStorage;
+  patternMatcher?: PatternMatcher;
   defaultLimit?: number;
   defaultThreshold?: number;
   defaultFormat?: 'compact' | 'verbose';
@@ -52,6 +54,7 @@ export class InspectAdapter extends ToolAdapter {
     this.patternService = new PatternAnalysisService({
       repositoryPath: config.repositoryPath,
       vectorStorage: config.vectorStorage,
+      patternMatcher: config.patternMatcher,
     });
     this.defaultLimit = config.defaultLimit ?? 10;
     this.defaultThreshold = config.defaultThreshold ?? 0.7;

From ac23d2d4f4ef1bcc61d5a3e54d10c66924ad7506 Mon Sep 17 00:00:00 2001
From: prosdev <prosdevlab@gmail.com>
Date: Tue, 31 Mar 2026 02:52:39 -0700
Subject: [PATCH 6/8] =?UTF-8?q?fix(core):=20address=20code=20review=20?=
 =?UTF-8?q?=E2=80=94=20WASM=20cleanup,=20type=20coverage=20accuracy?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- Fix Query object WASM leak: call q.delete() in finally after matches()
- Fix type coverage ratio inflation: add arrow-total and function-total
  queries for accurate denominator (was counting only typed functions)
- Fix try/catch-alone classification: fall through to regex instead of
  mapping to 'throw' style (try-catch is a mechanism, not a style)
- Add comment explaining AST/regex import count asymmetry

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---
 packages/core/src/pattern-matcher/rules.ts        | 12 ++++++++++++
 packages/core/src/scanner/tree-sitter.ts          |  5 ++++-
 .../core/src/services/pattern-analysis-service.ts | 15 ++++++++++-----
 3 files changed, 26 insertions(+), 6 deletions(-)

diff --git a/packages/core/src/pattern-matcher/rules.ts b/packages/core/src/pattern-matcher/rules.ts
index 4d945c6..ef80b66 100644
--- a/packages/core/src/pattern-matcher/rules.ts
+++ b/packages/core/src/pattern-matcher/rules.ts
@@ -90,6 +90,18 @@ export const TYPE_COVERAGE_QUERIES: PatternMatchRule[] = [
     category: 'type-coverage',
     query: '(function_declaration return_type: (type_annotation)) @match',
   },
+  {
+    // Count ALL arrow functions (typed or not) for accurate denominator
+    id: 'arrow-total',
+    category: 'type-coverage',
+    query: '(arrow_function) @match',
+  },
+  {
+    // Count ALL function declarations (typed or not) for accurate denominator
+    id: 'function-total',
+    category: 'type-coverage',
+    query: '(function_declaration) @match',
+  },
 ];
 
 // ============================================================================
diff --git a/packages/core/src/scanner/tree-sitter.ts b/packages/core/src/scanner/tree-sitter.ts
index 83a4448..c966824 100644
--- a/packages/core/src/scanner/tree-sitter.ts
+++ b/packages/core/src/scanner/tree-sitter.ts
@@ -365,13 +365,16 @@ export async function runQueries(
 
     const QueryCls = QueryClass;
     for (const { id, query: queryString } of queries) {
+      let q: InstanceType<typeof QueryCls> | null = null;
       try {
-        const q = new QueryCls(lang, queryString);
+        q = new QueryCls(lang, queryString);
         const matches = q.matches(tree.rootNode);
         results.set(id, matches.length);
       } catch {
         // Invalid query — skip, return 0 for this rule
         results.set(id, 0);
+      } finally {
+        q?.delete();
       }
     }
   } catch {
diff --git a/packages/core/src/services/pattern-analysis-service.ts b/packages/core/src/services/pattern-analysis-service.ts
index 943c780..4b06987 100644
--- a/packages/core/src/services/pattern-analysis-service.ts
+++ b/packages/core/src/services/pattern-analysis-service.ts
@@ -152,8 +152,8 @@ export async function extractErrorHandlingWithAst(
   }
   if (hasThrow) return { style: 'throw', examples: [] };
   if (hasResultRegex) return regex; // AST can't detect Result<T>, keep regex
-  if (hasTryCatch || hasPromiseCatch) return { style: 'throw', examples: [] };
-
+  // try-catch or promise.catch alone is a mechanism, not a style —
+  // fall through to regex which may have found throw/Result in content
   return regex;
 }
 
@@ -174,7 +174,9 @@ export async function extractImportStyleWithAst(
   const reExports = ast.get('re-export') ?? 0;
   const requires = ast.get('require') ?? 0;
 
-  // Dynamic imports count as ESM
+  // AST affects style classification but not importCount — importCount only adds
+  // genuinely new detections (dynamic imports) that regex missed. AST require
+  // matches overlap with regex require matches so they don't inflate the count.
   const esmCount =
     (regex.style === 'esm' || regex.style === 'mixed' ? regex.importCount : 0) +
     dynamicImports +
@@ -206,11 +208,14 @@ export async function extractTypeCoverageWithAst(
 
   const arrowTyped = ast.get('arrow-return-type') ?? 0;
   const functionTyped = ast.get('function-return-type') ?? 0;
+  const arrowTotal = ast.get('arrow-total') ?? 0;
+  const functionTotal = ast.get('function-total') ?? 0;
   const astAnnotated = arrowTyped + functionTyped;
+  const astTotal = arrowTotal + functionTotal;
 
-  // Merge: use the higher count (AST catches arrows that signatures miss)
+  // Merge: use the higher of AST total vs regex total for accurate denominator
   const annotatedCount = Math.max(regex.annotatedCount, astAnnotated);
-  const totalCount = Math.max(regex.totalCount, astAnnotated); // at least as many as annotated
+  const totalCount = Math.max(regex.totalCount, astTotal);
 
   if (totalCount === 0) return regex;
 

From b1d3496d5c8567cfb5886d319e85b3fda015e7c0 Mon Sep 17 00:00:00 2001
From: prosdev <prosdevlab@gmail.com>
Date: Tue, 31 Mar 2026 02:59:46 -0700
Subject: [PATCH 7/8] test(core): add extractor merge logic and denominator
 query tests

Fill the test coverage gaps identified in review:
- 3 tests for arrow-total/function-total denominator queries
- 7 tests for extractErrorHandlingWithAst merge logic
- 4 tests for extractImportStyleWithAst merge logic
- 5 tests for extractTypeCoverageWithAst merge logic (accurate denominator)
- Fallback tests verifying matcher=undefined produces identical regex output

51 tests total in wasm-matcher.test.ts (was 32). 1628 tests pass overall.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---
 .../__tests__/wasm-matcher.test.ts            | 196 ++++++++++++++++++
 1 file changed, 196 insertions(+)

diff --git a/packages/core/src/pattern-matcher/__tests__/wasm-matcher.test.ts b/packages/core/src/pattern-matcher/__tests__/wasm-matcher.test.ts
index 2fd8429..96a943f 100644
--- a/packages/core/src/pattern-matcher/__tests__/wasm-matcher.test.ts
+++ b/packages/core/src/pattern-matcher/__tests__/wasm-matcher.test.ts
@@ -9,6 +9,14 @@
 import * as fs from 'node:fs/promises';
 import * as path from 'node:path';
 import { beforeAll, describe, expect, it } from 'vitest';
+import {
+  extractErrorHandlingFromContent,
+  extractErrorHandlingWithAst,
+  extractImportStyleFromContent,
+  extractImportStyleWithAst,
+  extractTypeCoverageFromSignatures,
+  extractTypeCoverageWithAst,
+} from '../../services/pattern-analysis-service';
 import {
   ALL_QUERIES,
   ERROR_HANDLING_QUERIES,
@@ -343,3 +351,191 @@ describe('resolveLanguage', () => {
     expect(resolveLanguage('README.md')).toBeUndefined();
   });
 });
+
+// ========================================================================
+// Denominator queries (arrow-total, function-total)
+// ========================================================================
+
+describe('total count queries', () => {
+  let matcher: PatternMatcher;
+
+  beforeAll(() => {
+    matcher = createPatternMatcher();
+  });
+
+  it('arrow-total counts all arrow functions (typed and untyped)', async () => {
+    const source = [
+      'const typed = (x: number): number => x;',
+      'const untyped = (x) => x;',
+      'const another = () => "hello";',
+    ].join('\n');
+    const results = await matcher.match(source, 'typescript', TYPE_COVERAGE_QUERIES);
+    expect(results.get('arrow-total')).toBe(3);
+    expect(results.get('arrow-return-type')).toBe(1); // only typed
+  });
+
+  it('function-total counts all function declarations', async () => {
+    const source = [
+      'function typed(x: number): number { return x; }',
+      'function untyped(x) { return x; }',
+    ].join('\n');
+    const results = await matcher.match(source, 'typescript', TYPE_COVERAGE_QUERIES);
+    expect(results.get('function-total')).toBe(2);
+    expect(results.get('function-return-type')).toBe(1);
+  });
+
+  it('returns 0 for code with no functions', async () => {
+    const results = await matcher.match('const x = 1;', 'typescript', TYPE_COVERAGE_QUERIES);
+    expect(results.get('arrow-total')).toBe(0);
+    expect(results.get('function-total')).toBe(0);
+  });
+});
+
+// ========================================================================
+// AST-enhanced extractor merge logic
+// ========================================================================
+
+describe('extractErrorHandlingWithAst', () => {
+  let matcher: PatternMatcher;
+
+  beforeAll(() => {
+    matcher = createPatternMatcher();
+  });
+
+  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');
+  });
+
+  it('throw only → throw', async () => {
+    const source = 'throw new Error("bad");';
+    const result = await extractErrorHandlingWithAst(source, 'test.ts', matcher);
+    expect(result.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);
+    // regex sees no throw/Result either → 'unknown'
+    expect(result.style).toBe('unknown');
+  });
+
+  it('Result<T> from regex + try-catch from AST → mixed', 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');
+  });
+
+  it('promise.catch only → unknown (no style mapping)', async () => {
+    const source = 'fetch("/api").catch(log);';
+    const result = await extractErrorHandlingWithAst(source, 'test.ts', matcher);
+    expect(result.style).toBe('unknown');
+  });
+
+  it('matcher=undefined → identical to regex', async () => {
+    const source = 'throw new Error("bad"); function f(): Result<string> {}';
+    const withMatcher = await extractErrorHandlingWithAst(source, 'test.ts', undefined);
+    const regexOnly = extractErrorHandlingFromContent(source);
+    expect(withMatcher).toEqual(regexOnly);
+  });
+
+  it('unsupported extension → falls back to regex', async () => {
+    const source = 'throw new Error("bad");';
+    const result = await extractErrorHandlingWithAst(source, 'test.py', matcher);
+    const regexOnly = extractErrorHandlingFromContent(source);
+    expect(result).toEqual(regexOnly);
+  });
+});
+
+describe('extractImportStyleWithAst', () => {
+  let matcher: PatternMatcher;
+
+  beforeAll(() => {
+    matcher = createPatternMatcher();
+  });
+
+  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);
+    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');
+  });
+
+  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');
+  });
+
+  it('matcher=undefined → identical to regex', async () => {
+    const source = 'import foo from "./bar";';
+    const withMatcher = await extractImportStyleWithAst(source, 'test.ts', undefined);
+    const regexOnly = extractImportStyleFromContent(source);
+    expect(withMatcher).toEqual(regexOnly);
+  });
+});
+
+describe('extractTypeCoverageWithAst', () => {
+  let matcher: PatternMatcher;
+
+  beforeAll(() => {
+    matcher = createPatternMatcher();
+  });
+
+  it('all functions typed → full', async () => {
+    const source = [
+      '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, []);
+    expect(result.coverage).toBe('full');
+    expect(result.annotatedCount).toBe(2);
+    expect(result.totalCount).toBe(2);
+  });
+
+  it('some functions typed → partial (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, []);
+    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');
+  });
+
+  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);
+    expect(result.annotatedCount).toBe(1);
+    expect(result.totalCount).toBe(1);
+    expect(result.coverage).toBe('full');
+  });
+
+  it('matcher=undefined → identical to regex signatures', async () => {
+    const signatures = ['function foo(x: string): number'];
+    const withMatcher = await extractTypeCoverageWithAst('', 'test.ts', undefined, signatures);
+    const regexOnly = extractTypeCoverageFromSignatures(signatures);
+    expect(withMatcher).toEqual(regexOnly);
+  });
+});

From 5e369574b14ee7453f6f76e15d221af9bf0fad52 Mon Sep 17 00:00:00 2001
From: prosdev <prosdevlab@gmail.com>
Date: Tue, 31 Mar 2026 03:04:10 -0700
Subject: [PATCH 8/8] =?UTF-8?q?refactor(core):=20parse=20once=20per=20file?=
 =?UTF-8?q?,=20not=203x=20=E2=80=94=20extractors=20take=20pre-computed=20A?=
 =?UTF-8?q?ST?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

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>
---
 .claude/scratchpad.md                         |  4 +
 .../__tests__/wasm-matcher.test.ts            | 89 ++++++++++---------
 .../src/services/pattern-analysis-service.ts  | 79 +++++++---------
 3 files changed, 81 insertions(+), 91 deletions(-)

diff --git a/.claude/scratchpad.md b/.claude/scratchpad.md
index 6d3cfb0..e0cc770 100644
--- a/.claude/scratchpad.md
+++ b/.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.
diff --git a/packages/core/src/pattern-matcher/__tests__/wasm-matcher.test.ts b/packages/core/src/pattern-matcher/__tests__/wasm-matcher.test.ts
index 96a943f..110b120 100644
--- a/packages/core/src/pattern-matcher/__tests__/wasm-matcher.test.ts
+++ b/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,19 +498,21 @@ 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);
@@ -518,24 +520,23 @@ describe('extractTypeCoverageWithAst', () => {
 
   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)
+    );
   });
 });
diff --git a/packages/core/src/services/pattern-analysis-service.ts b/packages/core/src/services/pattern-analysis-service.ts
index 4b06987..d4afc6f 100644
--- a/packages/core/src/services/pattern-analysis-service.ts
+++ b/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),
     };
   }