@backthread/extractor 0.1.0

package/dist/graph/incremental.js

@@ -0,0 +1,448 @@
+// Stage A — the diff-driven incremental extraction ENGINE.
+//
+// Owns a ts-morph Project + a FileGraphState (file-graph.ts) across a merge
+// walk's checkpoints. The walk seeds it ONCE (full extract, or the
+// extraction_cache's serialized file graph with ZERO symbol work), then PATCHES
+// it per checkpoint from `git diff --name-status` — re-running the expensive
+// type-checker call-edge extraction only on the changed files + the dependents
+// that can observe the change (computeCallPatchUnit), and re-resolving import
+// specifiers fresh wherever the tree's shape moved.
+//
+// WHY the working tree stays checked out per checkpoint: import/call resolution
+// is the ts-morph compiler's (Bundler resolution, tsconfig paths, extensionless
+// + .js→.ts mapping). Re-implementing it against a bare tree index would risk
+// silent divergence from a full extract — the one thing Stage A must not do.
+// `git checkout` between adjacent merges only rewrites the changed paths, so
+// the checkout itself is already O(diff); what this engine eliminates is the
+// O(repo) parse + symbol-resolution per checkpoint.
+//
+// Patch modes per checkpoint:
+//   * content-only diff (M) → refresh just those SourceFiles in the live
+//     Project (no re-parse of anything else; resolution can't move when the
+//     tree shape is unchanged).
+//   * shape diff (A/D/T)    → rebuild the Project from disk (syntactic parse,
+//     seconds) + re-resolve EVERY file's imports (cheap) — catching "an
+//     existing `./util` import now resolves to the new file" exactly like a
+//     full extract would. Call extraction still runs only on the patch unit.
+//   * config invalidator    → the caller runs a FULL re-seed instead (the
+//     correctness valve; tsconfig/package/lockfiles can move resolution
+//     globally).
+//
+// EQUIVALENCE CONTRACT: at every checkpoint the patched graph must equal a
+// fresh full extract of the same tree — guarded by incremental-equivalence
+// fixture test. See file-graph.ts for the STEP-1 finding + the documented
+// residual (deep type-dispatch chains), healed by invalidators + Stage B
+// reconciliation.
+import { resolve } from 'node:path';
+import { classifyDiff, computeCallPatchUnit, deserializeFileGraph, graphFromState, serializeFileGraph, } from './file-graph.js';
+import { filterNoise, summarizeNoise } from './noise-filter.js';
+import { addAllSourceFiles, buildExtractionProject, extractFileCalls, extractFileImportsRecord, extractFileRecord, toId, } from './ts-morph-adapter.js';
+export class IncrementalExtractor {
+    project = null;
+    state = null;
+    /**
+     * Stage B — paths whose records were (RE)COMPUTED this boot: exactly
+     * the rows worth upserting into the blob parse-cache at boot end. Patch-unit
+     * members + full-extract files only — NOT imports-only-refreshed files (their
+     * cached record's stale-resolved imports only feed the moved-bindings check
+     * on reuse, which re-validates against the live tree anyway; marking them
+     * would upsert the whole repo every boot for nothing). Paths that leave the
+     * state (deleted files) are dropped — their blobs aren't in the final tree.
+     */
+    dirty = new Set();
+    /**
+     * log the noise-filter policy at most ONCE per engine lifetime (=
+     * once per boot). The filter runs on every seed/patch return (so the
+     * clustering-bound graph is always clean), but a per-checkpoint log line would
+     * spam the merge walk with the same drop every checkpoint. Logging once — at
+     * the first checkpoint that drops anything, whether that's a seed or a patch —
+     * keeps the house rule (never a silent cap) without the noise.
+     */
+    noiseLogged = false;
+    /**
+     * drop tests/generated/build/config/stories/mocks/types from the
+     * clustering-bound graph. Deterministic + pure; the carried FileGraphState is
+     * left intact (filtering is an OUTPUT concern only — incremental patching, the
+     * blob cache, and the Stage-A/B equivalence contract are unaffected).
+     */
+    applyNoiseFilter(graph) {
+        const { graph: filtered, dropped } = filterNoise(graph);
+        if (dropped.total > 0 && !this.noiseLogged) {
+            console.log(`  ⊘ ${summarizeNoise(dropped)}`);
+            this.noiseLogged = true;
+        }
+        return filtered;
+    }
+    /** Is there a carried state to patch from? */
+    get hasState() {
+        return this.state !== null;
+    }
+    /** The FULL commit sha the carried state corresponds to (diff base). */
+    get headSha() {
+        return this.state?.headSha ?? null;
+    }
+    /**
+     * Adopt a serialized file graph (the extraction_cache seed) — ZERO parsing.
+     * Returns false (and stays unseeded) when the payload isn't usable.
+     */
+    adoptCache(serialized) {
+        const state = deserializeFileGraph(serialized);
+        if (!state)
+            return false;
+        this.state = state;
+        this.project = null; // built lazily on the first patch
+        this.dirty.clear(); // nothing recomputed — every record came from the cache
+        return true;
+    }
+    /**
+     * Adopt a ground-truth state DIRECTLY (the Stage-B reconciliation heal —
+     * container.ts swaps in a fresh full extract's state when drift is found).
+     * The caller marks the drifted paths dirty itself (markDirty) so the heal
+     * reaches the blob cache; the engine's existing dirty set stays valid (non-
+     * drifted records are identical by definition of the diff).
+     */
+    adoptState(state) {
+        this.state = state;
+        this.project = null; // rebuilt lazily on the next patch
+        for (const path of this.dirty) {
+            if (!(path in state.files))
+                this.dirty.delete(path);
+        }
+    }
+    /** Paths whose records were (re)computed this boot — the blob-cache upserts. */
+    dirtyPaths() {
+        return [...this.dirty];
+    }
+    /** Forget the dirty set (call after a successful blob-cache upsert). */
+    clearDirty() {
+        this.dirty.clear();
+    }
+    /** Mark paths dirty (the reconciliation heal's drifted set). */
+    markDirty(paths) {
+        for (const p of paths)
+            this.dirty.add(p);
+    }
+    /** The carried record for a path (blob-cache row material), or null. */
+    recordFor(path) {
+        return this.state?.files[path] ?? null;
+    }
+    /** The carried state (reconciliation comparator input). Do not mutate. */
+    stateSnapshot() {
+        if (!this.state)
+            throw new Error('IncrementalExtractor.stateSnapshot before seed');
+        return this.state;
+    }
+    /**
+     * Full extract at the current working tree (the seed, or the config-
+     * invalidator fallback). Same work as the batch adapter — kept for the
+     * boot's FIRST checkpoint when no usable cache seed exists.
+     */
+    seedFull(repoDir, headSha) {
+        const root = resolve(repoDir);
+        // release any prior Project BEFORE building its replacement so the
+        // old ts-morph AST + resolution state is collectible during the (re)build,
+        // instead of two full Projects coexisting. That transient ~2x heap is what
+        // OOM-aborted the container (exit 134) when a large monorepo's window hit a
+        // config invalidator and re-entered seedFull mid-walk.
+        this.project = null;
+        const project = buildExtractionProject(root);
+        addAllSourceFiles(project, root);
+        const sourceFiles = project.getSourceFiles();
+        const internalIds = new Set(sourceFiles.map((sf) => toId(root, sf.getFilePath())));
+        const files = {};
+        for (const sf of sourceFiles) {
+            files[toId(root, sf.getFilePath())] = extractFileRecord(sf, root, internalIds);
+        }
+        this.project = project;
+        this.state = { headSha, files };
+        // Everything was recomputed → everything is blob-cache upsert material;
+        // previously-dirty paths that left the tree drop with the new state.
+        this.dirty = new Set(Object.keys(files));
+        return {
+            graph: this.applyNoiseFilter(graphFromState(root, this.state)),
+            metrics: {
+                mode: 'seed-full',
+                parsedFiles: sourceFiles.length,
+                callExtracted: sourceFiles.length,
+                carried: 0,
+                filesTotal: sourceFiles.length,
+            },
+        };
+    }
+    /**
+     * Stage B — seed from the content-addressed BLOB PARSE-CACHE: the
+     * cold-boot path when no carried graph exists (or its head commit is
+     * unreachable in the clone) but per-blob records survive in
+     * `file_parse_cache`. `cached` is keyed by repo-relative path and contains
+     * ONLY records whose blobSha already matched the current tree — the CALLER
+     * does the blob matching (container.ts joins lsTreeBlobs against the cache).
+     *
+     * CORRECTNESS (the patchTo argument with "diff = cache misses"): a cached
+     * record's CALLS are reused only when
+     *   (a) the content is blob-identical (the caller's join),
+     *   (b) its freshly-resolved import bindings equal the cached ones (the
+     *       moved-bindings check below — this also heals a blob that matched at
+     *       a DIFFERENT path, where relative specifiers resolve elsewhere), and
+     *   (c) no re-export chain connects it to a miss (the closure).
+     * Imports/externals/reexports are re-resolved FRESH for every file (cheap;
+     * resolution must reflect THIS tree). Same documented residual as Stage A
+     * (deep type-dispatch chains), healed by the periodic reconciliation pass.
+     */
+    seedFromBlobCache(repoDir, headSha, cached) {
+        const root = resolve(repoDir);
+        // 1. Syntactic parse of the whole tree — unavoidable on a cold boot
+        //    (seconds); the expensive type-checker work below is O(misses + moved).
+        const project = buildExtractionProject(root);
+        addAllSourceFiles(project, root);
+        const sourceFiles = project.getSourceFiles();
+        const internalIds = new Set(sourceFiles.map((sf) => toId(root, sf.getFilePath())));
+        const sfById = new Map(sourceFiles.map((sf) => [toId(root, sf.getFilePath()), sf]));
+        // 2. Misses = current source files without a blob-matched cached record.
+        const misses = [];
+        for (const id of internalIds) {
+            if (!cached.has(id))
+                misses.push(id);
+        }
+        // 3. Fresh import resolution for EVERY file (must be current-tree).
+        const freshImports = new Map(); // calls EMPTY (filled below)
+        for (const id of internalIds) {
+            const sf = sfById.get(id);
+            if (!sf)
+                continue;
+            freshImports.set(id, extractFileImportsRecord(sf, root, internalIds));
+        }
+        const importsView = new Map();
+        const reexportsView = new Map();
+        for (const [id, rec] of freshImports) {
+            importsView.set(id, rec.imports);
+            reexportsView.set(id, rec.reexports);
+        }
+        // The "previous" import view = the cached records' (a miss has no entry →
+        // computeCallPatchUnit treats it as new and pulls it into the unit).
+        const prevImports = new Map([...cached].map(([id, rec]) => [id, rec.imports]));
+        // 4. The call patch unit: misses + moved bindings + re-export closure
+        //    importers — exactly patchTo's rule with "diff = cache misses".
+        const unit = computeCallPatchUnit({
+            added: misses,
+            modified: [],
+            deleted: [],
+            freshImports: importsView,
+            prevImports,
+            reexports: reexportsView,
+        });
+        // 5. Assemble: unit members pay the symbol work; the rest reuse cached
+        //    calls (pruned to the current tree — a full extract could never emit
+        //    an edge to a file that isn't here).
+        const files = {};
+        let callExtracted = 0;
+        let carried = 0;
+        for (const id of internalIds) {
+            const sf = sfById.get(id);
+            const base = freshImports.get(id) ?? extractFileImportsRecord(sf, root, internalIds);
+            if (unit.has(id)) {
+                files[id] = { ...base, calls: extractFileCalls(sf, root, internalIds) };
+                callExtracted++;
+            }
+            else {
+                // Non-unit ⇒ cached.has(id) by construction (every miss joined the unit).
+                files[id] = {
+                    ...base,
+                    calls: (cached.get(id)?.calls ?? []).filter((c) => internalIds.has(c.to)),
+                };
+                carried++;
+            }
+        }
+        this.project = project;
+        this.state = { headSha, files };
+        // Only the unit's records were (re)computed — those join the upsert set;
+        // carried records already live in the blob cache (that's where they came
+        // from). Paths no longer in the state drop (their blobs left the tree).
+        for (const id of unit)
+            this.dirty.add(id);
+        for (const path of this.dirty) {
+            if (!(path in files))
+                this.dirty.delete(path);
+        }
+        return {
+            graph: this.applyNoiseFilter(graphFromState(root, this.state)),
+            metrics: {
+                mode: 'seed-blob-cache',
+                parsedFiles: sourceFiles.length,
+                callExtracted,
+                carried,
+                filesTotal: Object.keys(files).length,
+            },
+        };
+    }
+    /**
+     * Patch the carried state to the tree currently checked out at `repoDir`
+     * (commit `headSha`), given the name-status diff from the carried head to
+     * this commit. The caller is responsible for the config-invalidator check
+     * (classifyDiff(...).invalidators → call seedFull instead).
+     */
+    patchTo(repoDir, headSha, diff) {
+        if (!this.state)
+            throw new Error('IncrementalExtractor.patchTo before seed');
+        const root = resolve(repoDir);
+        const cls = classifyDiff(diff);
+        const seededFromCache = this.project === null;
+        // --- 1. Bring the Project in line with the tree ------------------------
+        let parsedFiles = 0;
+        let rebuilt = false;
+        if (this.project === null || cls.shapeChanged) {
+            // Shape moved (or first patch after a cache seed) → rebuild from disk.
+            // Syntactic parse of the tree (seconds); the expensive symbol work below
+            // stays O(patch unit). A fresh Project also sidesteps any module-
+            // resolution cache staleness across adds/deletes.
+            // drop the prior Project BEFORE building the replacement (build
+            // into a local, then assign) so the old ts-morph Project is collectible
+            // during the rebuild instead of both coexisting — the 2x-heap transient
+            // that OOM-aborted the container (exit 134) on a large monorepo whose
+            // window hit a config invalidator. (seededFromCache was captured above.)
+            this.project = null;
+            const rebuiltProject = buildExtractionProject(root);
+            addAllSourceFiles(rebuiltProject, root);
+            this.project = rebuiltProject;
+            parsedFiles = rebuiltProject.getSourceFiles().length;
+            rebuilt = true;
+        }
+        else {
+            // Content-only diff → refresh exactly the modified files in place.
+            for (const path of cls.sourceModified) {
+                const abs = `${root}/${path}`;
+                const sf = this.project.getSourceFile(abs);
+                if (sf) {
+                    sf.refreshFromFileSystemSync();
+                }
+                else {
+                    // Defensive: the carried project should contain it; add if not.
+                    this.project.addSourceFileAtPath(abs);
+                }
+                parsedFiles++;
+            }
+        }
+        const project = this.project;
+        const sourceFiles = project.getSourceFiles();
+        const internalIds = new Set(sourceFiles.map((sf) => toId(root, sf.getFilePath())));
+        const sfById = new Map(sourceFiles.map((sf) => [toId(root, sf.getFilePath()), sf]));
+        // --- 2. Import/re-export/external resolution ---------------------------
+        // Fresh wherever resolution can have moved: every file on a rebuild (tree
+        // shape changed), only the modified files on a refresh (shape unchanged ⇒
+        // unchanged files' specifiers bind identically). extractFileRecord also
+        // produces the file's calls — for files OUTSIDE the call patch unit we
+        // overwrite them with the carried ones below, so the expensive symbol pass
+        // effectively runs only where needed... except extractFileRecord computes
+        // calls inline. To keep symbol work O(patch unit), resolution-only files
+        // get a cheap imports-only pass instead.
+        const prevFiles = this.state.files;
+        const freshImports = new Map(); // imports/externals/reexports fresh; calls EMPTY (filled below)
+        const importsOnlyTargets = rebuilt
+            ? [...internalIds]
+            : cls.sourceModified.filter((p) => internalIds.has(p));
+        for (const id of importsOnlyTargets) {
+            const sf = sfById.get(id);
+            if (!sf)
+                continue;
+            freshImports.set(id, extractFileImportsRecord(sf, root, internalIds));
+        }
+        // Per-file import views for the patch-unit computation: fresh where
+        // recomputed, carried otherwise (valid — resolution didn't move there).
+        const importsView = new Map();
+        const reexportsView = new Map();
+        for (const id of internalIds) {
+            const fresh = freshImports.get(id);
+            const prev = prevFiles[id];
+            importsView.set(id, fresh ? fresh.imports : (prev?.imports ?? []));
+            reexportsView.set(id, fresh ? fresh.reexports : (prev?.reexports ?? []));
+        }
+        const prevImports = new Map(Object.entries(prevFiles).map(([id, rec]) => [id, rec.imports]));
+        // --- 3. The call patch unit (the expensive symbol work) ----------------
+        const unit = computeCallPatchUnit({
+            added: cls.sourceAdded.filter((p) => internalIds.has(p)),
+            modified: cls.sourceModified.filter((p) => internalIds.has(p)),
+            deleted: cls.sourceDeleted,
+            freshImports: importsView,
+            prevImports,
+            reexports: reexportsView,
+        });
+        // --- 4. Assemble the new state -----------------------------------------
+        const files = {};
+        let callExtracted = 0;
+        let carried = 0;
+        for (const id of internalIds) {
+            const sf = sfById.get(id);
+            if (unit.has(id)) {
+                // Full per-file extraction: reuse the fresh import half when it was
+                // already computed above, add the expensive call half.
+                const base = freshImports.get(id) ?? extractFileImportsRecord(sf, root, internalIds);
+                files[id] = { ...base, calls: extractFileCalls(sf, root, internalIds) };
+                callExtracted++;
+                this.dirty.add(id); // (re)computed → blob-cache upsert material
+                continue;
+            }
+            const prev = prevFiles[id];
+            const freshNoCalls = freshImports.get(id);
+            if (freshNoCalls) {
+                // Imports re-resolved (rebuild path) but calls carried — the unit
+                // computation proved this file's bindings didn't move. Prune any
+                // carried call edge whose target left the tree (a full extract could
+                // not produce it). NOT marked dirty: the record's call half came from
+                // the carried state, and its imports-only refresh is re-validated on
+                // every reuse anyway (the moved-bindings check).
+                files[id] = {
+                    ...freshNoCalls,
+                    calls: (prev?.calls ?? []).filter((c) => internalIds.has(c.to)),
+                };
+                carried++;
+            }
+            else if (prev) {
+                files[id] = {
+                    ...prev,
+                    calls: prev.calls.filter((c) => internalIds.has(c.to)),
+                    imports: prev.imports.filter((e) => internalIds.has(e.to)),
+                };
+                carried++;
+            }
+            else {
+                // Shouldn't happen (a file neither carried nor in the unit) — extract
+                // defensively rather than dropping it.
+                files[id] = extractFileRecord(sf, root, internalIds);
+                callExtracted++;
+                this.dirty.add(id);
+            }
+        }
+        this.state = { headSha, files };
+        // Paths that left the state this patch are no longer upsert material.
+        for (const path of this.dirty) {
+            if (!(path in files))
+                this.dirty.delete(path);
+        }
+        return {
+            graph: this.applyNoiseFilter(graphFromState(root, this.state)),
+            metrics: {
+                mode: seededFromCache ? 'seed-cache' : rebuilt ? 'patch-rebuild' : 'patch-refresh',
+                parsedFiles,
+                callExtracted,
+                carried,
+                filesTotal: Object.keys(files).length,
+            },
+        };
+    }
+    /** Serialize the carried state for the extraction_cache fileGraph payload. */
+    toCachePayload(blobShaByPath) {
+        if (!this.state)
+            return null;
+        return serializeFileGraph(this.state, blobShaByPath);
+    }
+    /**
+     * The NormalizedGraph view of the carried state (test/diagnostic read).
+     * RAW — deliberately NOT noise-filtered: this is the carried-state
+     * view the equivalence tests assert against, not a clustering-bound return.
+     */
+    graphSnapshot(root) {
+        if (!this.state)
+            throw new Error('IncrementalExtractor.graphSnapshot before seed');
+        return graphFromState(resolve(root), this.state);
+    }
+}
+//# sourceMappingURL=incremental.js.map

package/dist/graph/incremental.js.map

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

package/dist/graph/language.d.ts

@@ -0,0 +1,31 @@
+import type { NormalizedGraph } from './types.js';
+import { type SourceLang } from './file-graph.js';
+/**
+ * Repo-relative POSIX paths of every source file for `lang` under `root`.
+ * Walks the tree directly (the Pyright adapter needs an explicit file list; it
+ * doesn't glob like ts-morph). Skips excluded + dot-prefixed directories and
+ * never follows symlinks (a symlinked dir reports isDirectory() === false), so a
+ * link into `.venv`/`site-packages` can't smuggle installed deps into the graph
+ * or escape the repo — a load-bearing part of the install-free promise.
+ */
+export declare function listSourceFiles(root: string, lang: SourceLang): string[];
+/**
+ * Pick the structural adapter language for `repoDir`. TS is the DEFAULT (the
+ * pipeline's home turf); Python is selected only when the repo is unambiguously
+ * Python. Manifests decide the clear cases cheaply (a Python-only manifest with
+ * no TS manifest → Python, and vice versa); a repo with both (or neither) falls
+ * back to a source-file count, so a TS app that merely ships a helper `.py`
+ * script still extracts as TS.
+ */
+export declare function detectRepoLanguage(repoDir: string): SourceLang;
+/**
+ * The languages the pipeline should extract + merge for `repoDir`. Returns ONE
+ * language for a single-language repo (identical to `detectRepoLanguage`, so no
+ * behavior change), or BOTH — dominant first (deterministic) — for a genuinely
+ * polyglot repo. The order is stable (count desc, then name) so the merged graph
+ * is deterministic.
+ */
+export declare function detectRepoLanguages(repoDir: string): SourceLang[];
+/** The language a NormalizedGraph was extracted in (derived from its file tags). */
+export declare function graphLanguage(graph: NormalizedGraph): SourceLang;
+//# sourceMappingURL=language.d.ts.map

package/dist/graph/language.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"language.d.ts","sourceRoot":"","sources":["../../src/graph/language.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAClD,OAAO,EAIL,KAAK,UAAU,EAChB,MAAM,iBAAiB,CAAC;AAKzB;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,UAAU,GAAG,MAAM,EAAE,CA0BxE;AAoCD;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,GAAG,UAAU,CAO9D;AAWD;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,MAAM,GAAG,UAAU,EAAE,CAcjE;AAED,oFAAoF;AACpF,wBAAgB,aAAa,CAAC,KAAK,EAAE,eAAe,GAAG,UAAU,CAEhE"}

package/dist/graph/language.js

@@ -0,0 +1,146 @@
+// Language detection + source-file enumeration for the extractor dispatch
+//. The pipeline runs ONE structural adapter per repo; this module
+// decides which (ts-morph vs Pyright) and, for the Pyright path, hands it the
+// explicit list of first-party source files to parse.
+//
+// IMPURE by design (reads the filesystem) — kept OUT of file-graph.ts, which is
+// the pure source-path policy. This module composes that policy (isSourceFilePath,
+// the exclude sets) with real fs walks.
+import { readdirSync, existsSync } from 'node:fs';
+import { relative, resolve } from 'node:path';
+import { isSourceFilePath, PYTHON_EXCLUDE_DIRS, EXCLUDE_DIRS, } from './file-graph.js';
+const PYTHON_MANIFESTS = ['pyproject.toml', 'setup.py', 'setup.cfg', 'requirements.txt', 'Pipfile'];
+const TS_MANIFESTS = ['package.json', 'tsconfig.json', 'tsconfig.base.json', 'jsconfig.json'];
+/**
+ * Repo-relative POSIX paths of every source file for `lang` under `root`.
+ * Walks the tree directly (the Pyright adapter needs an explicit file list; it
+ * doesn't glob like ts-morph). Skips excluded + dot-prefixed directories and
+ * never follows symlinks (a symlinked dir reports isDirectory() === false), so a
+ * link into `.venv`/`site-packages` can't smuggle installed deps into the graph
+ * or escape the repo — a load-bearing part of the install-free promise.
+ */
+export function listSourceFiles(root, lang) {
+    const absRoot = resolve(root);
+    const excludes = new Set(lang === 'python' ? PYTHON_EXCLUDE_DIRS : EXCLUDE_DIRS);
+    const out = [];
+    const walk = (dir) => {
+        let entries;
+        try {
+            entries = readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            return; // unreadable dir — skip, never fail the whole extraction
+        }
+        for (const ent of entries) {
+            const abs = `${dir}/${ent.name}`;
+            if (ent.isDirectory()) {
+                if (ent.name.startsWith('.') || excludes.has(ent.name))
+                    continue;
+                walk(abs);
+            }
+            else if (ent.isFile()) {
+                const id = relative(absRoot, abs).split(/[\\/]/).join('/');
+                if (isSourceFilePath(id, lang))
+                    out.push(id);
+            }
+            // symlinks (isDirectory/isFile both false) are intentionally skipped
+        }
+    };
+    walk(absRoot);
+    return out.sort();
+}
+/** Count source files per language under `root` (bounded walk short-circuits). */
+function countSources(root, cap = 4000) {
+    let ts = 0;
+    let python = 0;
+    const absRoot = resolve(root);
+    const tsExcl = new Set(EXCLUDE_DIRS);
+    const pyExcl = new Set(PYTHON_EXCLUDE_DIRS);
+    const walk = (dir) => {
+        if (ts + python >= cap)
+            return;
+        let entries;
+        try {
+            entries = readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const ent of entries) {
+            if (ts + python >= cap)
+                return;
+            const abs = `${dir}/${ent.name}`;
+            if (ent.isDirectory()) {
+                // Skip a dir excluded by EITHER language (or dot-prefixed) — the union
+                // keeps the count cheap and can't misread vendored deps as source.
+                if (ent.name.startsWith('.') || tsExcl.has(ent.name) || pyExcl.has(ent.name))
+                    continue;
+                walk(abs);
+            }
+            else if (ent.isFile()) {
+                const id = relative(absRoot, abs).split(/[\\/]/).join('/');
+                if (isSourceFilePath(id, 'ts'))
+                    ts++;
+                else if (isSourceFilePath(id, 'python'))
+                    python++;
+            }
+        }
+    };
+    walk(absRoot);
+    return { ts, python };
+}
+/**
+ * Pick the structural adapter language for `repoDir`. TS is the DEFAULT (the
+ * pipeline's home turf); Python is selected only when the repo is unambiguously
+ * Python. Manifests decide the clear cases cheaply (a Python-only manifest with
+ * no TS manifest → Python, and vice versa); a repo with both (or neither) falls
+ * back to a source-file count, so a TS app that merely ships a helper `.py`
+ * script still extracts as TS.
+ */
+export function detectRepoLanguage(repoDir) {
+    const hasPy = PYTHON_MANIFESTS.some((m) => existsSync(resolve(repoDir, m)));
+    const hasTs = TS_MANIFESTS.some((m) => existsSync(resolve(repoDir, m)));
+    if (hasPy && !hasTs)
+        return 'python';
+    if (hasTs && !hasPy)
+        return 'ts';
+    const { ts, python } = countSources(repoDir);
+    return python > ts ? 'python' : 'ts';
+}
+// a language is only a FIRST-CLASS participant in the diagram when it has
+// a MEANINGFUL presence — enough files (absolute) AND a big-enough share of the
+// larger language. This keeps a TS repo shipping a couple of helper `.py` scripts
+// (or a Python repo with a stray build script) extracting as a SINGLE language,
+// byte-identical to before — only a genuinely polyglot repo (a TS frontend + a
+// Python backend) triggers the multi-extract merge.
+const MULTI_MIN_FILES = 5;
+const MULTI_MIN_FRACTION = 0.15;
+/**
+ * The languages the pipeline should extract + merge for `repoDir`. Returns ONE
+ * language for a single-language repo (identical to `detectRepoLanguage`, so no
+ * behavior change), or BOTH — dominant first (deterministic) — for a genuinely
+ * polyglot repo. The order is stable (count desc, then name) so the merged graph
+ * is deterministic.
+ */
+export function detectRepoLanguages(repoDir) {
+    const { ts, python } = countSources(repoDir);
+    const all = [
+        { lang: 'ts', count: ts },
+        { lang: 'python', count: python },
+    ];
+    const counts = all.filter((l) => l.count > 0);
+    if (counts.length <= 1)
+        return [detectRepoLanguage(repoDir)];
+    const max = Math.max(ts, python);
+    const present = counts.filter((l) => l.count >= MULTI_MIN_FILES && l.count / max >= MULTI_MIN_FRACTION);
+    if (present.length <= 1)
+        return [detectRepoLanguage(repoDir)];
+    return present
+        .sort((a, b) => b.count - a.count || (a.lang < b.lang ? -1 : 1))
+        .map((l) => l.lang);
+}
+/** The language a NormalizedGraph was extracted in (derived from its file tags). */
+export function graphLanguage(graph) {
+    return graph.files.some((f) => f.language === 'py' || f.language === 'pyi') ? 'python' : 'ts';
+}
+//# sourceMappingURL=language.js.map