@getfoyer/review-core 0.1.0 → 0.2.1

package/dist/semantic/imports.js

@@ -0,0 +1,102 @@
+/**
+ * Import-edge resolution.
+ *
+ * Given an import like `import { foo, bar } from './utils'` in
+ * `src/services/billing.ts`, resolve `./utils` to a real repo path, fetch
+ * that file via the FileReader, parse it, and extract the signatures of
+ * `foo` and `bar`.
+ *
+ * Resolution rules (intentionally cheap):
+ *   - Relative paths only (`.` or `..`). Bare-module specifiers (`react`,
+ *     `lodash`) are skipped — we'd need package.json + node_modules walking
+ *     to handle those, and signatures of third-party deps rarely catch bugs
+ *     the diff alone misses.
+ *   - Try the literal path, then `<path>.ts`, `.tsx`, `.js`, `.jsx`,
+ *     `.py`, then `<path>/index.ts` / `.js`. Skip the rest. The plan calls
+ *     this "1-hop"; we explicitly do NOT recurse.
+ *
+ * Returns at most `cap` imported symbols total across the call to keep the
+ * rendered block bounded.
+ */
+import { dirname, posix } from 'node:path';
+import { languageForPath } from './languages.js';
+import { parse } from './parser.js';
+import { topLevelDefinitions, symbolName } from './symbols.js';
+const RELATIVE_CANDIDATE_SUFFIXES = ['', '.ts', '.tsx', '.js', '.jsx', '.py', '.rb'];
+const INDEX_SUFFIXES = ['/index.ts', '/index.tsx', '/index.js', '/index.jsx', '/__init__.py'];
+function isRelative(spec) {
+    return spec.startsWith('./') || spec.startsWith('../') || spec === '.' || spec === '..';
+}
+function candidatePaths(fromFile, spec) {
+    const baseDir = dirname(fromFile);
+    const joined = posix.normalize(posix.join(baseDir, spec));
+    const out = [];
+    // TS/ESM convention: source imports `./foo.js` but the actual file on disk
+    // is `./foo.ts`. Try the TS-equivalent before the literal so common cases
+    // resolve on the first hit. Also handles `.jsx → .tsx`, `.mjs → .mts`, etc.
+    const jsToTs = {
+        '.js': '.ts',
+        '.jsx': '.tsx',
+        '.mjs': '.mts',
+        '.cjs': '.cts',
+    };
+    const extMatch = /(\.[a-z]+)$/i.exec(joined);
+    if (extMatch && jsToTs[extMatch[1]]) {
+        out.push(joined.slice(0, -extMatch[1].length) + jsToTs[extMatch[1]]);
+    }
+    for (const sfx of RELATIVE_CANDIDATE_SUFFIXES) {
+        out.push(joined + sfx);
+    }
+    for (const sfx of INDEX_SUFFIXES) {
+        out.push(joined + sfx);
+    }
+    return out;
+}
+async function resolveImport(reader, fromFile, spec) {
+    if (!isRelative(spec))
+        return null;
+    for (const candidate of candidatePaths(fromFile, spec)) {
+        const content = await reader.read(candidate);
+        if (content !== null)
+            return { path: candidate, content };
+    }
+    return null;
+}
+export async function resolveImports(input) {
+    const collected = [];
+    for (const edge of input.edges) {
+        if (collected.length >= input.cap)
+            break;
+        if (!isRelative(edge.source))
+            continue;
+        const resolved = await resolveImport(input.reader, input.fromFile, edge.source);
+        if (!resolved)
+            continue;
+        const lang = languageForPath(resolved.path);
+        if (!lang)
+            continue;
+        const parsed = await parse(resolved.content, lang);
+        if (!parsed)
+            continue;
+        const defs = topLevelDefinitions(parsed, lang);
+        const wanted = new Set(edge.names);
+        const wantsAll = wanted.has('*');
+        for (const def of defs) {
+            if (collected.length >= input.cap)
+                break;
+            const nm = symbolName(def);
+            if (!wantsAll && !wanted.has(nm))
+                continue;
+            // Signature = first line of the body. For TS interfaces / type aliases
+            // the "first line" is the only meaningful part anyway.
+            const firstLine = def.text.split('\n', 1)[0].trim();
+            collected.push({
+                name: nm,
+                fromFile: resolved.path,
+                signature: firstLine,
+            });
+        }
+    }
+    return collected;
+}
+//# sourceMappingURL=imports.js.map

package/dist/semantic/imports.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"imports.js","sourceRoot":"","sources":["../../src/semantic/imports.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,WAAW,CAAC;AAE3C,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AACjD,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AACpC,OAAO,EAAE,mBAAmB,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAG/D,MAAM,2BAA2B,GAAG,CAAC,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC;AACrF,MAAM,cAAc,GAAG,CAAC,WAAW,EAAE,YAAY,EAAE,WAAW,EAAE,YAAY,EAAE,cAAc,CAAC,CAAC;AAE9F,SAAS,UAAU,CAAC,IAAY;IAC9B,OAAO,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,IAAI,IAAI,KAAK,GAAG,IAAI,IAAI,KAAK,IAAI,CAAC;AAC1F,CAAC;AAED,SAAS,cAAc,CAAC,QAAgB,EAAE,IAAY;IACpD,MAAM,OAAO,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAC;IAClC,MAAM,MAAM,GAAG,KAAK,CAAC,SAAS,CAAC,KAAK,CAAC,IAAI,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC,CAAC;IAC1D,MAAM,GAAG,GAAa,EAAE,CAAC;IACzB,2EAA2E;IAC3E,0EAA0E;IAC1E,4EAA4E;IAC5E,MAAM,MAAM,GAA2B;QACrC,KAAK,EAAE,KAAK;QACZ,MAAM,EAAE,MAAM;QACd,MAAM,EAAE,MAAM;QACd,MAAM,EAAE,MAAM;KACf,CAAC;IACF,MAAM,QAAQ,GAAG,cAAc,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IAC7C,IAAI,QAAQ,IAAI,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;QACpC,GAAG,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IACvE,CAAC;IACD,KAAK,MAAM,GAAG,IAAI,2BAA2B,EAAE,CAAC;QAC9C,GAAG,CAAC,IAAI,CAAC,MAAM,GAAG,GAAG,CAAC,CAAC;IACzB,CAAC;IACD,KAAK,MAAM,GAAG,IAAI,cAAc,EAAE,CAAC;QACjC,GAAG,CAAC,IAAI,CAAC,MAAM,GAAG,GAAG,CAAC,CAAC;IACzB,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC;AAED,KAAK,UAAU,aAAa,CAAC,MAAkB,EAAE,QAAgB,EAAE,IAAY;IAC7E,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC;QAAE,OAAO,IAAI,CAAC;IACnC,KAAK,MAAM,SAAS,IAAI,cAAc,CAAC,QAAQ,EAAE,IAAI,CAAC,EAAE,CAAC;QACvD,MAAM,OAAO,GAAG,MAAM,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;QAC7C,IAAI,OAAO,KAAK,IAAI;YAAE,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE,OAAO,EAAE,CAAC;IAC5D,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC;AAYD,MAAM,CAAC,KAAK,UAAU,cAAc,CAAC,KAA4B;IAC/D,MAAM,SAAS,GAAqB,EAAE,CAAC;IACvC,KAAK,MAAM,IAAI,IAAI,KAAK,CAAC,KAAK,EAAE,CAAC;QAC/B,IAAI,SAAS,CAAC,MAAM,IAAI,KAAK,CAAC,GAAG;YAAE,MAAM;QACzC,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,MAAM,CAAC;YAAE,SAAS;QACvC,MAAM,QAAQ,GAAG,MAAM,aAAa,CAAC,KAAK,CAAC,MAAM,EAAE,KAAK,CAAC,QAAQ,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC;QAChF,IAAI,CAAC,QAAQ;YAAE,SAAS;QACxB,MAAM,IAAI,GAAG,eAAe,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;QAC5C,IAAI,CAAC,IAAI;YAAE,SAAS;QACpB,MAAM,MAAM,GAAG,MAAM,KAAK,CAAC,QAAQ,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;QACnD,IAAI,CAAC,MAAM;YAAE,SAAS;QACtB,MAAM,IAAI,GAAG,mBAAmB,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;QAC/C,MAAM,MAAM,GAAG,IAAI,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QACnC,MAAM,QAAQ,GAAG,MAAM,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QACjC,KAAK,MAAM,GAAG,IAAI,IAAI,EAAE,CAAC;YACvB,IAAI,SAAS,CAAC,MAAM,IAAI,KAAK,CAAC,GAAG;gBAAE,MAAM;YACzC,MAAM,EAAE,GAAG,UAAU,CAAC,GAAG,CAAC,CAAC;YAC3B,IAAI,CAAC,QAAQ,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC;gBAAE,SAAS;YAC3C,uEAAuE;YACvE,uDAAuD;YACvD,MAAM,SAAS,GAAG,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC;YACpD,SAAS,CAAC,IAAI,CAAC;gBACb,IAAI,EAAE,EAAE;gBACR,QAAQ,EAAE,QAAQ,CAAC,IAAI;gBACvB,SAAS,EAAE,SAAS;aACrB,CAAC,CAAC;QACL,CAAC;IACH,CAAC;IACD,OAAO,SAAS,CAAC;AACnB,CAAC"}

package/dist/semantic/index.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Public entry point: build a `<semantic_context>` block to inline next to
+ * the diff in the code-review LLM user message.
+ *
+ * Never throws. Any failure (grammar load, file fetch, parse) returns an
+ * empty `SemanticBlock` and the caller proceeds with diff-only — same as
+ * Foyer behaves today.
+ *
+ * Timing: this runs in the pre-sandbox static pass alongside `code_review`.
+ * It uses `FileReader` (Octokit-backed) rather than a `SandboxHandle`,
+ * because at this point in the orchestrator no workspace exists yet.
+ * Cross-file caller search would require a workspace and is deferred —
+ * see `~/.claude/plans/implement-ast-parsing-for-scalable-charm.md`.
+ */
+import type { FileReader } from '../fileReader.js';
+import { type SemanticBlockCache } from './cache.js';
+import type { SemanticBlock } from './types.js';
+export interface BuildSemanticContextOptions {
+    /** Hard cap on the rendered block (bytes). Default: 30_000. */
+    maxBytes?: number;
+    /** Cap on bytes per individual symbol body before slicing. Default: 4_000. */
+    bodyCapBytes?: number;
+    /** Cap on imported-symbol entries across the whole block. Default: 30. */
+    importedCap?: number;
+    /** Cap on files we'll parse in one call. Default: 20. Protects against
+     *  mega-PRs that touch hundreds of files. */
+    fileCap?: number;
+}
+export declare function buildSemanticContext(diff: string, reader: FileReader, options?: BuildSemanticContextOptions): Promise<SemanticBlock>;
+/**
+ * Cached variant: same `(repoFullName, headSha)` resolves through a shared
+ * LRU. The two consumers (`code_review`, `intent_fidelity`) hit the same key
+ * and the second one returns instantly. Falls through to a fresh build on
+ * miss, then stores. Pass `cache` to override the shared singleton in tests.
+ */
+export declare function buildSemanticContextCached(input: {
+    diff: string;
+    reader: FileReader;
+    repoFullName: string;
+    headSha: string;
+}, options?: BuildSemanticContextOptions, cache?: SemanticBlockCache): Promise<SemanticBlock>;
+export type { SemanticBlock, TouchedSymbol, ImportedSymbol } from './types.js';
+export { getSharedSemanticBlockCache, _resetSharedCacheForTests } from './cache.js';
+export type { SemanticBlockCache } from './cache.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/semantic/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/semantic/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAOnD,OAAO,EAGL,KAAK,kBAAkB,EACxB,MAAM,YAAY,CAAC;AACpB,OAAO,KAAK,EAAE,aAAa,EAAiC,MAAM,YAAY,CAAC;AAE/E,MAAM,WAAW,2BAA2B;IAC1C,+DAA+D;IAC/D,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,8EAA8E;IAC9E,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,0EAA0E;IAC1E,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;iDAC6C;IAC7C,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AASD,wBAAsB,oBAAoB,CACxC,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,UAAU,EAClB,OAAO,GAAE,2BAAgC,GACxC,OAAO,CAAC,aAAa,CAAC,CA8CxB;AAED;;;;;GAKG;AACH,wBAAsB,0BAA0B,CAC9C,KAAK,EAAE;IACL,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,UAAU,CAAC;IACnB,YAAY,EAAE,MAAM,CAAC;IACrB,OAAO,EAAE,MAAM,CAAC;CACjB,EACD,OAAO,GAAE,2BAAgC,EACzC,KAAK,GAAE,kBAAkD,GACxD,OAAO,CAAC,aAAa,CAAC,CASxB;AAED,YAAY,EAAE,aAAa,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAC/E,OAAO,EAAE,2BAA2B,EAAE,yBAAyB,EAAE,MAAM,YAAY,CAAC;AACpF,YAAY,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC"}

package/dist/semantic/index.js

@@ -0,0 +1,78 @@
+import { touchedFiles } from './diffParse.js';
+import { languageForPath } from './languages.js';
+import { parse } from './parser.js';
+import { findTouchedSymbols, findImports } from './symbols.js';
+import { resolveImports } from './imports.js';
+import { renderSemanticBlock } from './contextBuilder.js';
+import { cacheKey, getSharedSemanticBlockCache, } from './cache.js';
+const DEFAULT_OPTS = {
+    maxBytes: 30_000,
+    bodyCapBytes: 4_000,
+    importedCap: 30,
+    fileCap: 20,
+};
+export async function buildSemanticContext(diff, reader, options = {}) {
+    const opts = { ...DEFAULT_OPTS, ...options };
+    if (!diff || diff.trim().length === 0) {
+        return { rendered: '', stats: { touchedFiles: 0, touchedSymbols: 0, importedSymbols: 0, bytes: 0, truncated: false } };
+    }
+    try {
+        const files = touchedFiles(diff).slice(0, opts.fileCap);
+        if (files.length === 0) {
+            return { rendered: '', stats: { touchedFiles: 0, touchedSymbols: 0, importedSymbols: 0, bytes: 0, truncated: false } };
+        }
+        const touched = [];
+        const imported = [];
+        const remainingImportBudget = () => opts.importedCap - imported.length;
+        for (const file of files) {
+            const lang = languageForPath(file.path);
+            if (!lang)
+                continue;
+            const source = await reader.read(file.path);
+            if (source === null)
+                continue;
+            const parsed = await parse(source, lang);
+            if (!parsed)
+                continue;
+            const fileSymbols = findTouchedSymbols(parsed, lang, file.path, file.hunks, opts.bodyCapBytes);
+            touched.push(...fileSymbols);
+            // Only bother resolving imports for files that actually have touched
+            // symbols — if the diff is a config edit, the imports aren't useful.
+            if (fileSymbols.length > 0 && remainingImportBudget() > 0) {
+                const edges = findImports(parsed, lang);
+                const resolved = await resolveImports({
+                    fromFile: file.path,
+                    edges,
+                    reader,
+                    cap: remainingImportBudget(),
+                });
+                imported.push(...resolved);
+            }
+        }
+        return renderSemanticBlock({ touched, imported, maxBytes: opts.maxBytes });
+    }
+    catch {
+        // Never block a review on enrichment failure.
+        return { rendered: '', stats: { touchedFiles: 0, touchedSymbols: 0, importedSymbols: 0, bytes: 0, truncated: false } };
+    }
+}
+/**
+ * Cached variant: same `(repoFullName, headSha)` resolves through a shared
+ * LRU. The two consumers (`code_review`, `intent_fidelity`) hit the same key
+ * and the second one returns instantly. Falls through to a fresh build on
+ * miss, then stores. Pass `cache` to override the shared singleton in tests.
+ */
+export async function buildSemanticContextCached(input, options = {}, cache = getSharedSemanticBlockCache()) {
+    const key = cacheKey(input.repoFullName, input.headSha);
+    const cached = cache.get(key);
+    if (cached)
+        return cached;
+    const fresh = await buildSemanticContext(input.diff, input.reader, options);
+    // Only cache non-empty blocks. Empty results from a transient failure
+    // (e.g. parser cold-start race) should be retryable on the next consumer.
+    if (fresh.rendered.length > 0)
+        cache.set(key, fresh);
+    return fresh;
+}
+export { getSharedSemanticBlockCache, _resetSharedCacheForTests } from './cache.js';
+//# sourceMappingURL=index.js.map

package/dist/semantic/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/semantic/index.ts"],"names":[],"mappings":"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"}

package/dist/semantic/languages.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Extension → grammar mapping. Unknown extensions resolve to null and the
+ * semantic builder silently skips the file (degrades to diff-only for that
+ * path). Adding a language = one entry here + a new WASM in tree-sitter-wasms.
+ */
+import type { LanguageId } from './types.js';
+export declare function languageForPath(path: string): LanguageId | null;
+/**
+ * Filename of the WASM grammar inside the `tree-sitter-wasms` package. Both
+ * `tsx` and `typescript` ship as separate WASMs because the TypeScript grammar
+ * upstream is split that way.
+ */
+export declare function wasmFileForLanguage(lang: LanguageId): string;
+//# sourceMappingURL=languages.d.ts.map

package/dist/semantic/languages.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"languages.d.ts","sourceRoot":"","sources":["../../src/semantic/languages.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAmB7C,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU,GAAG,IAAI,CAK/D;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,UAAU,GAAG,MAAM,CAU5D"}

package/dist/semantic/languages.js

@@ -0,0 +1,40 @@
+const EXTENSION_TO_LANGUAGE = {
+    ts: 'typescript',
+    cts: 'typescript',
+    mts: 'typescript',
+    tsx: 'tsx',
+    js: 'javascript',
+    cjs: 'javascript',
+    mjs: 'javascript',
+    jsx: 'javascript',
+    py: 'python',
+    pyi: 'python',
+    go: 'go',
+    rs: 'rust',
+    rb: 'ruby',
+    rake: 'ruby',
+};
+export function languageForPath(path) {
+    const idx = path.lastIndexOf('.');
+    if (idx < 0)
+        return null;
+    const ext = path.slice(idx + 1).toLowerCase();
+    return EXTENSION_TO_LANGUAGE[ext] ?? null;
+}
+/**
+ * Filename of the WASM grammar inside the `tree-sitter-wasms` package. Both
+ * `tsx` and `typescript` ship as separate WASMs because the TypeScript grammar
+ * upstream is split that way.
+ */
+export function wasmFileForLanguage(lang) {
+    switch (lang) {
+        case 'typescript': return 'tree-sitter-typescript.wasm';
+        case 'tsx': return 'tree-sitter-tsx.wasm';
+        case 'javascript': return 'tree-sitter-javascript.wasm';
+        case 'python': return 'tree-sitter-python.wasm';
+        case 'go': return 'tree-sitter-go.wasm';
+        case 'rust': return 'tree-sitter-rust.wasm';
+        case 'ruby': return 'tree-sitter-ruby.wasm';
+    }
+}
+//# sourceMappingURL=languages.js.map

package/dist/semantic/languages.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"languages.js","sourceRoot":"","sources":["../../src/semantic/languages.ts"],"names":[],"mappings":"AAOA,MAAM,qBAAqB,GAA+B;IACxD,EAAE,EAAE,YAAY;IAChB,GAAG,EAAE,YAAY;IACjB,GAAG,EAAE,YAAY;IACjB,GAAG,EAAE,KAAK;IACV,EAAE,EAAE,YAAY;IAChB,GAAG,EAAE,YAAY;IACjB,GAAG,EAAE,YAAY;IACjB,GAAG,EAAE,YAAY;IACjB,EAAE,EAAE,QAAQ;IACZ,GAAG,EAAE,QAAQ;IACb,EAAE,EAAE,IAAI;IACR,EAAE,EAAE,MAAM;IACV,EAAE,EAAE,MAAM;IACV,IAAI,EAAE,MAAM;CACb,CAAC;AAEF,MAAM,UAAU,eAAe,CAAC,IAAY;IAC1C,MAAM,GAAG,GAAG,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC;IAClC,IAAI,GAAG,GAAG,CAAC;QAAE,OAAO,IAAI,CAAC;IACzB,MAAM,GAAG,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC,WAAW,EAAE,CAAC;IAC9C,OAAO,qBAAqB,CAAC,GAAG,CAAC,IAAI,IAAI,CAAC;AAC5C,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,mBAAmB,CAAC,IAAgB;IAClD,QAAQ,IAAI,EAAE,CAAC;QACb,KAAK,YAAY,CAAC,CAAC,OAAO,6BAA6B,CAAC;QACxD,KAAK,KAAK,CAAC,CAAQ,OAAO,sBAAsB,CAAC;QACjD,KAAK,YAAY,CAAC,CAAC,OAAO,6BAA6B,CAAC;QACxD,KAAK,QAAQ,CAAC,CAAK,OAAO,yBAAyB,CAAC;QACpD,KAAK,IAAI,CAAC,CAAS,OAAO,qBAAqB,CAAC;QAChD,KAAK,MAAM,CAAC,CAAO,OAAO,uBAAuB,CAAC;QAClD,KAAK,MAAM,CAAC,CAAO,OAAO,uBAAuB,CAAC;IACpD,CAAC;AACH,CAAC"}

package/dist/semantic/parser.d.ts

@@ -0,0 +1,15 @@
+import { type Tree } from 'web-tree-sitter';
+import type { LanguageId } from './types.js';
+export interface ParseResult {
+    tree: Tree;
+    source: string;
+}
+/**
+ * Parse `source` as `lang`. Returns null when the grammar can't be loaded or
+ * when parsing throws. The caller treats null as "skip this file" and the
+ * semantic block degrades silently for that path.
+ */
+export declare function parse(source: string, lang: LanguageId): Promise<ParseResult | null>;
+/** Test seam: drop caches so a unit test can simulate a cold start. */
+export declare function _resetForTests(): void;
+//# sourceMappingURL=parser.d.ts.map

package/dist/semantic/parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parser.d.ts","sourceRoot":"","sources":["../../src/semantic/parser.ts"],"names":[],"mappings":"AAgBA,OAAO,EAAoB,KAAK,IAAI,EAAE,MAAM,iBAAiB,CAAC;AAE9D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AA0C7C,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,IAAI,CAAC;IACX,MAAM,EAAE,MAAM,CAAC;CAChB;AAED;;;;GAIG;AACH,wBAAsB,KAAK,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,WAAW,GAAG,IAAI,CAAC,CAYzF;AAED,uEAAuE;AACvE,wBAAgB,cAAc,IAAI,IAAI,CAGrC"}

package/dist/semantic/parser.js

@@ -0,0 +1,83 @@
+/**
+ * Lazy, process-singleton wrapper around web-tree-sitter.
+ *
+ * Loading WASM is async and not free (~5MB per grammar), so we initialise the
+ * runtime once and cache loaded grammars by `LanguageId`. Callers do not need
+ * to know about WASM — they ask for a `Tree` and either get one or `null` if
+ * the grammar fails to load (graceful degradation: the semantic block just
+ * skips that file).
+ *
+ * We intentionally don't expose Parser/Language to callers — every consumer
+ * just wants `parse(source, lang)`.
+ */
+import { readFile } from 'node:fs/promises';
+import { dirname, resolve } from 'node:path';
+import { createRequire } from 'node:module';
+import { Parser, Language } from 'web-tree-sitter';
+import { wasmFileForLanguage } from './languages.js';
+const require_ = createRequire(import.meta.url);
+let initPromise = null;
+const languageCache = new Map();
+async function ensureInit() {
+    if (initPromise)
+        return initPromise;
+    initPromise = (async () => {
+        // web-tree-sitter looks for `tree-sitter.wasm` next to its main module by
+        // default. We override `locateFile` to point at the package directly so
+        // node ESM resolution doesn't trip over import.meta.url plumbing.
+        const wtsMain = require_.resolve('web-tree-sitter');
+        const wtsDir = dirname(wtsMain);
+        await Parser.init({
+            locateFile: (name) => resolve(wtsDir, name),
+        });
+    })().catch((err) => {
+        // Reset on failure so a transient error doesn't poison the singleton.
+        initPromise = null;
+        throw err;
+    });
+    return initPromise;
+}
+async function loadGrammar(lang) {
+    if (languageCache.has(lang))
+        return languageCache.get(lang) ?? null;
+    try {
+        await ensureInit();
+        const wasmsDir = dirname(require_.resolve('tree-sitter-wasms/package.json'));
+        const wasmPath = resolve(wasmsDir, 'out', wasmFileForLanguage(lang));
+        const bytes = await readFile(wasmPath);
+        const language = await Language.load(bytes);
+        languageCache.set(lang, language);
+        return language;
+    }
+    catch {
+        languageCache.set(lang, null);
+        return null;
+    }
+}
+/**
+ * Parse `source` as `lang`. Returns null when the grammar can't be loaded or
+ * when parsing throws. The caller treats null as "skip this file" and the
+ * semantic block degrades silently for that path.
+ */
+export async function parse(source, lang) {
+    const language = await loadGrammar(lang);
+    if (!language)
+        return null;
+    try {
+        const parser = new Parser();
+        parser.setLanguage(language);
+        const tree = parser.parse(source);
+        if (!tree)
+            return null;
+        return { tree, source };
+    }
+    catch {
+        return null;
+    }
+}
+/** Test seam: drop caches so a unit test can simulate a cold start. */
+export function _resetForTests() {
+    initPromise = null;
+    languageCache.clear();
+}
+//# sourceMappingURL=parser.js.map

package/dist/semantic/parser.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parser.js","sourceRoot":"","sources":["../../src/semantic/parser.ts"],"names":[],"mappings":"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"}

package/dist/semantic/symbols.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Symbol extraction from a parsed AST.
+ *
+ * Two responsibilities:
+ *  1. Given a parsed file + a set of changed line ranges, return the top-level
+ *     symbols (functions, classes, methods) whose body overlaps any of those
+ *     ranges. Those are the "touched symbols" the reviewer should know about
+ *     in full, not just by diff hunks.
+ *  2. Given a parsed file, return its import edges: which modules it imports
+ *     and which named bindings it pulls in. The imports module resolves those
+ *     to files; the resolver lives outside so this stays AST-only.
+ *
+ * The grammars provide the node type strings; the per-language differences
+ * are isolated in `topLevelTypes` and `importQuery` below.
+ */
+import type { Node } from 'web-tree-sitter';
+import type { ParseResult } from './parser.js';
+import type { LanguageId, TouchedSymbol } from './types.js';
+/**
+ * Top-level definitions in order. We walk the root node's direct children
+ * (and one level into `export_statement` / `decorated_definition` wrappers).
+ */
+export declare function topLevelDefinitions(parsed: ParseResult, lang: LanguageId): Node[];
+/**
+ * Heuristic name extraction. Tree-sitter exposes a `name` field for most
+ * declaration types; for lexical_declaration we walk into the first
+ * variable_declarator and read its `name` field. Returns "<anonymous>" rather
+ * than null so the rendered block always has something printable.
+ */
+export declare function symbolName(node: Node): string;
+export declare function symbolKind(node: Node): TouchedSymbol['kind'];
+/**
+ * Return the symbols whose source range overlaps any of the supplied
+ * post-image line ranges. Lines are 1-based; tree-sitter positions are
+ * 0-based, so we shift by one when comparing.
+ */
+export declare function findTouchedSymbols(parsed: ParseResult, lang: LanguageId, file: string, hunks: {
+    newStart: number;
+    newLines: number;
+}[], bodyCapBytes: number): TouchedSymbol[];
+export interface ImportEdge {
+    /** Module specifier as it appears in source (e.g. `./foo`, `react`). */
+    source: string;
+    /** Local names imported. For `import * as X from ...` this is `['*']`. */
+    names: string[];
+}
+/**
+ * Extract import edges. JS/TS use `import_statement`; Python uses
+ * `import_from_statement` / `import_statement`. We surface only the cheap
+ * cases — full semantics (re-exports, computed paths) would require a real
+ * compiler, which is out of scope per the plan.
+ */
+export declare function findImports(parsed: ParseResult, lang: LanguageId): ImportEdge[];
+//# sourceMappingURL=symbols.d.ts.map

package/dist/semantic/symbols.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"symbols.d.ts","sourceRoot":"","sources":["../../src/semantic/symbols.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAC;AAC5C,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC/C,OAAO,KAAK,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AA4D5D;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,WAAW,EAAE,IAAI,EAAE,UAAU,GAAG,IAAI,EAAE,CAoBjF;AAED;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM,CA4B7C;AAED,wBAAgB,UAAU,CAAC,IAAI,EAAE,IAAI,GAAG,aAAa,CAAC,MAAM,CAAC,CA8B5D;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,WAAW,EACnB,IAAI,EAAE,UAAU,EAChB,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,EAAE,EAC/C,YAAY,EAAE,MAAM,GACnB,aAAa,EAAE,CA4BjB;AAMD,MAAM,WAAW,UAAU;IACzB,wEAAwE;IACxE,MAAM,EAAE,MAAM,CAAC;IACf,0EAA0E;IAC1E,KAAK,EAAE,MAAM,EAAE,CAAC;CACjB;AAED;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,MAAM,EAAE,WAAW,EAAE,IAAI,EAAE,UAAU,GAAG,UAAU,EAAE,CAsE/E"}