cgraphx 2.0.2 → 2.0.6

package/dist/core/code/engine/core/ingestion/import-resolvers/utils.js

@@ -0,0 +1,153 @@
+"use strict";
+/**
+ * Suffix-index helpers for import path resolution.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EXTENSIONS = void 0;
+exports.tryResolveWithExtensions = tryResolveWithExtensions;
+exports.buildSuffixIndex = buildSuffixIndex;
+exports.suffixResolve = suffixResolve;
+/** All file extensions to try during resolution */
+exports.EXTENSIONS = [
+    '',
+    // TypeScript/JavaScript
+    '.tsx',
+    '.ts',
+    '.mts',
+    '.cts',
+    '.jsx',
+    '.js',
+    '.mjs',
+    '.cjs',
+    '.vue',
+    '/index.tsx',
+    '/index.ts',
+    '/index.jsx',
+    '/index.js',
+    // Python
+    '.py',
+    '/__init__.py',
+    // Java
+    '.java',
+    // Kotlin
+    '.kt',
+    '.kts',
+    // C/C++
+    '.c',
+    '.h',
+    '.cpp',
+    '.hpp',
+    '.cc',
+    '.cxx',
+    '.hxx',
+    '.hh',
+    '.cu',
+    '.cuh',
+    // C#
+    '.cs',
+    // Go
+    '.go',
+    // Rust
+    '.rs',
+    '/mod.rs',
+    // PHP
+    '.php',
+    '.phtml',
+    // Swift
+    '.swift',
+    // Ruby
+    '.rb',
+];
+/**
+ * Try to match a path (with extensions) against the known file set.
+ * Returns the matched file path or null.
+ */
+function tryResolveWithExtensions(basePath, allFiles) {
+    for (const ext of exports.EXTENSIONS) {
+        const candidate = basePath + ext;
+        if (allFiles.has(candidate))
+            return candidate;
+    }
+    return null;
+}
+function buildSuffixIndex(normalizedFileList, allFileList) {
+    // Map: normalized suffix -> original file path
+    const exactMap = new Map();
+    // Map: lowercase suffix -> original file path
+    const lowerMap = new Map();
+    // Map: directory suffix -> list of file paths in that directory
+    const dirMap = new Map();
+    for (let i = 0; i < normalizedFileList.length; i++) {
+        const normalized = normalizedFileList[i];
+        const original = allFileList[i];
+        const parts = normalized.split('/');
+        // Index all suffixes: "a/b/c.java" -> ["c.java", "b/c.java", "a/b/c.java"]
+        for (let j = parts.length - 1; j >= 0; j--) {
+            const suffix = parts.slice(j).join('/');
+            // Only store first match (longest path wins for ambiguous suffixes)
+            if (!exactMap.has(suffix)) {
+                exactMap.set(suffix, original);
+            }
+            const lower = suffix.toLowerCase();
+            if (!lowerMap.has(lower)) {
+                lowerMap.set(lower, original);
+            }
+        }
+        // Index directory membership
+        const lastSlash = normalized.lastIndexOf('/');
+        if (lastSlash >= 0) {
+            // Build all directory suffixes
+            const dirParts = parts.slice(0, -1);
+            const fileName = parts[parts.length - 1];
+            const ext = fileName.substring(fileName.lastIndexOf('.'));
+            for (let j = dirParts.length - 1; j >= 0; j--) {
+                const dirSuffix = dirParts.slice(j).join('/');
+                const key = `${dirSuffix}:${ext}`;
+                let list = dirMap.get(key);
+                if (!list) {
+                    list = [];
+                    dirMap.set(key, list);
+                }
+                list.push(original);
+            }
+        }
+    }
+    return {
+        get: (suffix) => exactMap.get(suffix),
+        getInsensitive: (suffix) => lowerMap.get(suffix.toLowerCase()),
+        getFilesInDir: (dirSuffix, extension) => {
+            return dirMap.get(`${dirSuffix}:${extension}`) || [];
+        },
+    };
+}
+/**
+ * Suffix-based resolution using index. O(1) per lookup instead of O(files).
+ */
+function suffixResolve(pathParts, normalizedFileList, allFileList, index) {
+    if (index) {
+        for (let i = 0; i < pathParts.length; i++) {
+            const suffix = pathParts.slice(i).join('/');
+            for (const ext of exports.EXTENSIONS) {
+                const suffixWithExt = suffix + ext;
+                const result = index.get(suffixWithExt) || index.getInsensitive(suffixWithExt);
+                if (result)
+                    return result;
+            }
+        }
+        return null;
+    }
+    // Fallback: linear scan (for backward compatibility)
+    for (let i = 0; i < pathParts.length; i++) {
+        const suffix = pathParts.slice(i).join('/');
+        for (const ext of exports.EXTENSIONS) {
+            const suffixWithExt = suffix + ext;
+            const suffixPattern = '/' + suffixWithExt;
+            const matchIdx = normalizedFileList.findIndex((filePath) => filePath.endsWith(suffixPattern) ||
+                filePath.toLowerCase().endsWith(suffixPattern.toLowerCase()));
+            if (matchIdx !== -1) {
+                return allFileList[matchIdx];
+            }
+        }
+    }
+    return null;
+}

package/dist/core/code/engine/core/ingestion/import-target-adapter.js

@@ -0,0 +1,99 @@
+"use strict";
+/**
+ * Bridge between CLI-package per-language `ImportResolverFn`s and the
+ * shared `FinalizeHooks.resolveImportTarget` contract
+ * (RFC §5.2; Ring 2 PKG #922).
+ *
+ * The shared finalize algorithm (#915) asks one question:
+ *
+ *     resolveImportTarget(targetRaw, fromFile, workspaceIndex): string | null
+ *
+ * The CLI already has 16 language-specific resolvers satisfying a
+ * richer signature:
+ *
+ *     ImportResolverFn(rawImportPath, filePath, resolveCtx): ImportResult
+ *
+ * This module builds a dispatch adapter — one FinalizeHook implementation
+ * that looks up the file's language from its path and delegates to the
+ * right per-language resolver. Callers package per-language resolvers +
+ * a shared `ResolveCtx` into an opaque `ImportTargetWorkspace` and pass
+ * it as `workspaceIndex` to `finalizeScopeModel`.
+ *
+ * ## What's deliberately NOT here
+ *
+ *   - **Re-implementation of any per-language resolver.** We wrap the
+ *     existing `importResolver` field on each `LanguageProvider` — the
+ *     same code path the legacy DAG uses today.
+ *   - **Dynamic-import handling.** The shared finalize algorithm short-
+ *     circuits `ParsedImport { kind: 'dynamic-unresolved' }` before
+ *     calling `resolveImportTarget`, so the adapter never sees those.
+ *   - **`importPathPreprocessor`.** Preprocessing belongs inside the
+ *     provider's `interpretImport` hook (which writes the final
+ *     `ParsedImport.targetRaw`). By the time finalize passes a
+ *     `targetRaw` to this adapter, it is the string the provider wants
+ *     resolved verbatim.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildImportTargetWorkspace = buildImportTargetWorkspace;
+exports.resolveImportTargetAcrossLanguages = resolveImportTargetAcrossLanguages;
+const index_js_1 = require("../../../shared/index.js");
+/**
+ * Build the workspace index from a map of language → provider. Providers
+ * whose `importResolver` is absent are silently skipped (no language will
+ * ever hit that branch at dispatch time).
+ *
+ * The `resolveCtx` is shared across all languages. Callers assemble it
+ * once per run (the existing pipeline already does this for the legacy
+ * DAG) and hand it to both the legacy resolution path and this factory.
+ */
+function buildImportTargetWorkspace(providers, resolveCtx) {
+    const perLanguage = new Map();
+    for (const [lang, provider] of providers) {
+        if (provider.importResolver === undefined)
+            continue;
+        perLanguage.set(lang, { resolver: provider.importResolver, ctx: resolveCtx });
+    }
+    return { perLanguage };
+}
+/**
+ * The FinalizeHooks-compatible implementation. Dispatches on `fromFile`'s
+ * extension → per-language resolver. Returns the first resolved file,
+ * or `null` if the resolver returns `null` or doesn't know about the
+ * language.
+ *
+ * Picks the first entry of `files[]` for both `'files'` and `'package'`
+ * result kinds — the legacy pipeline uses the whole array, but the
+ * shared `finalize()` hook contract is single-file. If the workspace
+ * later needs richer semantics (split-target packages), this is the
+ * single site to extend.
+ */
+function resolveImportTargetAcrossLanguages(targetRaw, fromFile, workspaceIndex) {
+    const workspace = workspaceIndex;
+    if (workspace === undefined || workspace.perLanguage === undefined)
+        return null;
+    const lang = (0, index_js_1.getLanguageFromFilename)(fromFile);
+    if (lang === null)
+        return null;
+    const entry = workspace.perLanguage.get(lang);
+    if (entry === undefined)
+        return null;
+    let result;
+    try {
+        result = entry.resolver(targetRaw, fromFile, entry.ctx);
+    }
+    catch {
+        // Existing resolvers can throw on malformed inputs (e.g., Python
+        // relative paths above the workspace root). Swallow — the shared
+        // algorithm treats a null here as `linkStatus: 'unresolved'`, which
+        // is the right fallback.
+        return null;
+    }
+    if (result === null)
+        return null;
+    // Both `files` and `package` variants expose a `files` array; the
+    // package variant also carries `dirSuffix` which we ignore at the
+    // FinalizeHook boundary (single-file contract). Legacy consumers
+    // continue to see the full result via `importResolver` directly.
+    const first = result.files[0];
+    return first ?? null;
+}

package/dist/core/code/engine/core/ingestion/language-config.js

@@ -0,0 +1,391 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.csharpScanToEvidence = csharpScanToEvidence;
+exports.loadTsconfigPaths = loadTsconfigPaths;
+exports.loadGoModulePath = loadGoModulePath;
+exports.loadComposerConfig = loadComposerConfig;
+exports.scanCSharpProject = scanCSharpProject;
+exports.loadSwiftPackageConfig = loadSwiftPackageConfig;
+exports.loadImportConfigs = loadImportConfigs;
+const promises_1 = __importDefault(require("fs/promises"));
+const fs_1 = require("fs");
+const readline_1 = require("readline");
+const path_1 = __importDefault(require("path"));
+const env_js_1 = require("./utils/env.js");
+const logger_js_1 = require("../logger.js");
+/** Project the one-pass {@link CSharpProjectScan} into the
+ *  {@link CSharpNamespaceEvidence} both import-resolution legs thread to the
+ *  #1881 gate — one shape, two carriers (`ImportConfigs.csharpNamespaces` for
+ *  the legacy DAG, `CsharpResolutionConfig.namespaces` for the scope resolver).
+ *  Keeps the field mapping in one place so the two carriers can't drift. */
+function csharpScanToEvidence(scan) {
+    return {
+        declaredNamespaces: scan.declaredNamespaces,
+        rootNamespaces: scan.rootNamespaces,
+        truncated: scan.truncated,
+    };
+}
+// ============================================================================
+// LANGUAGE-SPECIFIC CONFIG LOADERS
+// ============================================================================
+/**
+ * Parse tsconfig.json to extract path aliases.
+ * Tries tsconfig.json, tsconfig.app.json, tsconfig.base.json in order.
+ */
+async function loadTsconfigPaths(repoRoot) {
+    const candidates = ['tsconfig.json', 'tsconfig.app.json', 'tsconfig.base.json'];
+    for (const filename of candidates) {
+        try {
+            const tsconfigPath = path_1.default.join(repoRoot, filename);
+            const raw = await promises_1.default.readFile(tsconfigPath, 'utf-8');
+            // Strip JSON comments (// and /* */ style) for robustness
+            const stripped = raw.replace(/\/\/.*$/gm, '').replace(/\/\*[\s\S]*?\*\//g, '');
+            const tsconfig = JSON.parse(stripped);
+            const compilerOptions = tsconfig.compilerOptions;
+            if (!compilerOptions?.paths)
+                continue;
+            const baseUrl = compilerOptions.baseUrl || '.';
+            const aliases = new Map();
+            for (const [pattern, targets] of Object.entries(compilerOptions.paths)) {
+                if (!Array.isArray(targets) || targets.length === 0)
+                    continue;
+                const target = targets[0];
+                // Convert glob patterns: "@/*" -> "@/", "src/*" -> "src/"
+                const aliasPrefix = pattern.endsWith('/*') ? pattern.slice(0, -1) : pattern;
+                const targetPrefix = target.endsWith('/*') ? target.slice(0, -1) : target;
+                aliases.set(aliasPrefix, targetPrefix);
+            }
+            if (aliases.size > 0) {
+                if (env_js_1.isDev) {
+                    logger_js_1.logger.info(`📦 Loaded ${aliases.size} path aliases from ${filename}`);
+                }
+                return { aliases, baseUrl };
+            }
+        }
+        catch {
+            // File doesn't exist or isn't valid JSON - try next
+        }
+    }
+    return null;
+}
+/**
+ * Parse go.mod to extract module path.
+ */
+async function loadGoModulePath(repoRoot) {
+    try {
+        const goModPath = path_1.default.join(repoRoot, 'go.mod');
+        const content = await promises_1.default.readFile(goModPath, 'utf-8');
+        const match = content.match(/^module\s+(\S+)/m);
+        if (match) {
+            if (env_js_1.isDev) {
+                logger_js_1.logger.info(`📦 Loaded Go module path: ${match[1]}`);
+            }
+            return { modulePath: match[1] };
+        }
+    }
+    catch {
+        // No go.mod
+    }
+    return null;
+}
+/** Parse composer.json to extract PSR-4 autoload mappings (including autoload-dev). */
+async function loadComposerConfig(repoRoot) {
+    try {
+        const composerPath = path_1.default.join(repoRoot, 'composer.json');
+        const raw = await promises_1.default.readFile(composerPath, 'utf-8');
+        const composer = JSON.parse(raw);
+        const psr4Raw = composer.autoload?.['psr-4'] ?? {};
+        const psr4Dev = composer['autoload-dev']?.['psr-4'] ?? {};
+        const merged = { ...psr4Raw, ...psr4Dev };
+        const psr4 = new Map();
+        for (const [ns, dir] of Object.entries(merged)) {
+            const nsNorm = ns.replace(/\\+$/, '');
+            const dirNorm = dir.replace(/\\/g, '/').replace(/\/+$/, '');
+            psr4.set(nsNorm, dirNorm);
+        }
+        if (env_js_1.isDev) {
+            logger_js_1.logger.info(`📦 Loaded ${psr4.size} PSR-4 mappings from composer.json`);
+        }
+        return { psr4 };
+    }
+    catch {
+        return null;
+    }
+}
+// BFS bounds shared by the C# project/namespace scan. Sized to comfortably
+// exceed normal C# repos so `truncated` stays the rare exception it was meant
+// to be: a too-low cap trips `truncated=true` on ordinary repos, which makes
+// `csharpSuffixFallbackAllowed` fail OPEN for every import and silently
+// disables the #1881 gate. Truncation remains the safety valve for genuinely
+// pathological trees (deep generated output, huge monorepos).
+const CSHARP_SCAN_MAX_DEPTH = 24;
+const CSHARP_SCAN_MAX_DIRS = 20000;
+// Bound on in-flight file reads per directory so a directory with thousands of
+// `.cs` files can't exhaust file descriptors / spike memory. Mirrors the
+// Phase-1 walker's `READ_CONCURRENCY` (see `filesystem-walker.ts`).
+const CSHARP_SCAN_READ_CONCURRENCY = 32;
+const CSHARP_SCAN_SKIP_DIRS = new Set(['node_modules', '.git', 'bin', 'obj']);
+const CSHARP_ROOT_NAMESPACE_RE = /<RootNamespace>\s*([^<]+)\s*<\/RootNamespace>/;
+// Declared `namespace` names are extracted with the comment/string-aware
+// scanner shared with the scope-resolution namespace-siblings pass
+// (`extractCsharpStructureViaScanner`), not a bare regex: a regex matches
+// `namespace` inside comments and string literals, seeding the #1881 gate
+// with phantom namespaces. Imported lazily (and memoized) so the always-on
+// `loadImportConfigs` path — every repo, every language — doesn't eagerly
+// pull tree-sitter-c-sharp in via `namespace-siblings.ts` → `query.ts`.
+let csharpScannerFactoryPromise;
+function getCsharpStructureScannerFactory() {
+    if (csharpScannerFactoryPromise === undefined) {
+        csharpScannerFactoryPromise = import('./languages/csharp/namespace-siblings.js').then((mod) => mod.createCsharpStructureScanner);
+    }
+    return csharpScannerFactoryPromise;
+}
+/**
+ * Single BFS over a repo that collects BOTH .csproj configs and the set of
+ * `namespace` declarations from `.cs` files.
+ *
+ * The csproj walk is cheap (a handful of project files); the namespace scan
+ * is NOT — it opens and reads every `.cs` file in the repo to collect its
+ * `namespace` declarations. That `.cs` read cost is the price of the #1881
+ * gate, not a saving: collapsing the csproj and namespace walks into one BFS
+ * avoids a second directory traversal, but the per-file `.cs` reads are new
+ * work this scan introduces. Reads within a directory are issued in bounded
+ * windows (see below); directories are still visited breadth-first.
+ */
+async function scanCSharpProject(repoRoot) {
+    const configs = [];
+    const declaredNamespaces = new Set();
+    const rootNamespaces = new Set();
+    const scanQueue = [{ dir: repoRoot, depth: 0 }];
+    let dirsScanned = 0;
+    let truncated = false;
+    while (scanQueue.length > 0) {
+        if (dirsScanned >= CSHARP_SCAN_MAX_DIRS) {
+            truncated = true;
+            break;
+        }
+        const { dir, depth } = scanQueue.shift();
+        dirsScanned++;
+        let entries;
+        try {
+            entries = await promises_1.default.readdir(dir, { withFileTypes: true });
+        }
+        catch {
+            // Unreadable directory → its `.cs` namespaces are missed, so the scan is
+            // incomplete. Mark truncated so the #1881 gate fails OPEN (allows the
+            // suffix fallback) rather than wrongly blocking an import whose declaring
+            // namespace lived in the unread subtree (#5).
+            truncated = true;
+            continue;
+        }
+        // Collect read targets, then issue them in bounded windows (rather than all
+        // at once) so a directory with thousands of `.cs` files can't exhaust file
+        // descriptors / spike memory. csproj reads keep entry order (config
+        // precedence matters); `.cs` namespace results land in shared Sets where
+        // order is irrelevant.
+        const csprojNames = [];
+        const csNames = [];
+        for (const entry of entries) {
+            if (entry.isDirectory()) {
+                if (CSHARP_SCAN_SKIP_DIRS.has(entry.name))
+                    continue;
+                if (depth < CSHARP_SCAN_MAX_DEPTH) {
+                    scanQueue.push({ dir: path_1.default.join(dir, entry.name), depth: depth + 1 });
+                }
+                else {
+                    truncated = true; // a real subtree was pruned at the depth cap
+                }
+                continue;
+            }
+            if (!entry.isFile())
+                continue;
+            if (entry.name.endsWith('.csproj')) {
+                csprojNames.push(entry.name);
+            }
+            else if (entry.name.endsWith('.cs')) {
+                csNames.push(entry.name);
+            }
+        }
+        for (let i = 0; i < csprojNames.length; i += CSHARP_SCAN_READ_CONCURRENCY) {
+            const batch = csprojNames.slice(i, i + CSHARP_SCAN_READ_CONCURRENCY);
+            const settled = await Promise.allSettled(batch.map((name) => readCsprojConfig(path_1.default.join(dir, name), name, repoRoot, dir)));
+            for (const r of settled) {
+                const config = r.status === 'fulfilled' ? r.value : null;
+                if (config) {
+                    configs.push(config);
+                    rootNamespaces.add(config.rootNamespace);
+                }
+            }
+        }
+        for (let i = 0; i < csNames.length; i += CSHARP_SCAN_READ_CONCURRENCY) {
+            const batch = csNames.slice(i, i + CSHARP_SCAN_READ_CONCURRENCY);
+            const settled = await Promise.allSettled(batch.map((name) => collectDeclaredNamespaces(path_1.default.join(dir, name), declaredNamespaces, rootNamespaces)));
+            // A `.cs` that was unreadable (or whose read/scan unexpectedly rejected)
+            // leaves its namespaces uncollected → mark truncated to fail the #1881
+            // gate OPEN rather than wrongly suppress an import. The scan streams each
+            // file, so file size no longer trips truncation.
+            for (const r of settled) {
+                if (r.status !== 'fulfilled' || r.value === 'truncated')
+                    truncated = true;
+            }
+        }
+    }
+    if (truncated) {
+        // Surface the fail-open so an incomplete scan (dir/depth cap, or an
+        // unreadable directory or `.cs` file) silently disabling the #1881 gate
+        // repo-wide is observable (#4) rather than a mystery edge regression.
+        logger_js_1.logger.warn(`[csharp] namespace scan of ${repoRoot} truncated (dir cap ${CSHARP_SCAN_MAX_DIRS}, depth cap ${CSHARP_SCAN_MAX_DEPTH}, an unreadable directory, or an unreadable .cs file); the #1881 suffix-fallback gate fails open for unmatched usings`);
+    }
+    return { configs, declaredNamespaces, rootNamespaces, truncated };
+}
+// Generous soft budget for locating `<RootNamespace>`: a real .csproj declares
+// it in the first PropertyGroup near the top, so this is only reached by a
+// pathological project file with a huge leading ItemGroup and no early
+// RootNamespace. On hit we OMIT the config rather than guess a root (Codex F4).
+const CSPROJ_ROOT_SCAN_MAX_BYTES = 4 * 1024 * 1024;
+// Overlap kept across stream chunks so a `<RootNamespace>` tag straddling a
+// chunk boundary is still matched (the tag + a short namespace value fit well
+// within this window).
+const CSPROJ_TAG_OVERLAP = 512;
+/**
+ * Stream a `.csproj` just far enough to find `<RootNamespace>`, in constant
+ * memory and without a stat-then-read filesystem race. Returns the namespace
+ * when found; otherwise `rootNamespace: null` with `capHit` distinguishing a
+ * genuine read-to-EOF absence (`false`) from "not found within the soft budget"
+ * (`true`) — so the caller never synthesizes a wrong filename root for a late
+ * tag (Codex F4).
+ */
+async function findCsprojRootNamespace(csprojPath) {
+    const stream = (0, fs_1.createReadStream)(csprojPath, { encoding: 'utf-8' });
+    let window = '';
+    let bytesRead = 0;
+    try {
+        for await (const chunk of stream) {
+            const text = chunk;
+            bytesRead += text.length;
+            window =
+                (window.length > CSPROJ_TAG_OVERLAP ? window.slice(-CSPROJ_TAG_OVERLAP) : window) + text;
+            const match = window.match(CSHARP_ROOT_NAMESPACE_RE);
+            if (match) {
+                stream.destroy();
+                return { rootNamespace: match[1].trim(), capHit: false };
+            }
+            if (bytesRead >= CSPROJ_ROOT_SCAN_MAX_BYTES) {
+                stream.destroy();
+                return { rootNamespace: null, capHit: true };
+            }
+        }
+    }
+    catch {
+        // Unreadable .csproj: don't guess a filename root either — omit the config.
+        return { rootNamespace: null, capHit: true };
+    }
+    return { rootNamespace: null, capHit: false }; // read to EOF, tag genuinely absent
+}
+async function readCsprojConfig(csprojPath, fileName, repoRoot, dir) {
+    const { rootNamespace: found, capHit } = await findCsprojRootNamespace(csprojPath);
+    // A late `<RootNamespace>` we couldn't reach (capHit) or an unreadable file
+    // must NOT synthesize a filename root — a wrong authoritative root would make
+    // imports under the real root resolve to nothing and suppress the fallback
+    // (Codex F4). Omit the config so the no-csproj fallback stays available. Only
+    // fall back to the filename on a genuine read-to-EOF absence of the tag.
+    if (capHit)
+        return null;
+    const rootNamespace = found ?? fileName.replace(/\.csproj$/, '');
+    const projectDir = path_1.default.relative(repoRoot, dir).replace(/\\/g, '/');
+    if (env_js_1.isDev) {
+        logger_js_1.logger.info(`📦 Loaded C# project: ${fileName} (namespace: ${rootNamespace}, dir: ${projectDir})`);
+    }
+    return { rootNamespace, projectDir };
+}
+/**
+ * Stream one `.cs` file line-by-line and collect its declared `namespace` names
+ * into the shared Sets.
+ *
+ * Streaming (rather than reading the whole file into a string) keeps memory
+ * constant regardless of file size, so a large generated `.cs` (`*.g.cs`, EF /
+ * gRPC output) is fully scanned instead of skipped by a per-file size cap —
+ * which would otherwise trip `truncated` and disable the #1881 gate repo-wide.
+ * Only the cheap line scan streams here; the tree-sitter PARSE path keeps its
+ * own size cap.
+ *
+ * Returns `'truncated'` when the file could not be read, so the caller marks the
+ * scan truncated and the #1881 gate fails OPEN rather than wrongly suppress an
+ * import declared in the unread file. Returns `'ok'` on a complete read.
+ */
+async function collectDeclaredNamespaces(filePath, declaredNamespaces, rootNamespaces) {
+    const createScanner = await getCsharpStructureScannerFactory();
+    const scanner = createScanner();
+    try {
+        // `crlfDelay: Infinity` treats every `\r\n` as a single break; the line
+        // scanner is terminator-agnostic, so a streamed scan yields the same
+        // namespaces as scanning the whole file content at once.
+        const lines = (0, readline_1.createInterface)({
+            input: (0, fs_1.createReadStream)(filePath, { encoding: 'utf-8' }),
+            crlfDelay: Infinity,
+        });
+        for await (const line of lines) {
+            scanner.pushLine(line);
+        }
+    }
+    catch {
+        return 'truncated'; // unreadable source → signal truncation (fail open)
+    }
+    const structure = scanner.result();
+    for (const ns of structure.namespaces) {
+        declaredNamespaces.add(ns);
+        const dot = ns.indexOf('.');
+        rootNamespaces.add(dot === -1 ? ns : ns.slice(0, dot));
+    }
+    // A declaration the scanner could not fully capture (Codex F3) means the
+    // collected namespaces are an incomplete picture of this file — treat it like
+    // a truncated read so the #1881 gate fails OPEN rather than over-block an
+    // import whose namespace was dropped.
+    return structure.incomplete ? 'truncated' : 'ok';
+}
+async function loadSwiftPackageConfig(repoRoot) {
+    // Swift imports are module-name based (e.g., `import SiuperModel`)
+    // SPM convention: Sources/<TargetName>/ or Package/Sources/<TargetName>/
+    // We scan for these directories to build a target map
+    const targets = new Map();
+    const sourceDirs = ['Sources', 'Package/Sources', 'src'];
+    for (const sourceDir of sourceDirs) {
+        try {
+            const fullPath = path_1.default.join(repoRoot, sourceDir);
+            const entries = await promises_1.default.readdir(fullPath, { withFileTypes: true });
+            for (const entry of entries) {
+                if (entry.isDirectory()) {
+                    targets.set(entry.name, sourceDir + '/' + entry.name);
+                }
+            }
+        }
+        catch {
+            // Directory doesn't exist
+        }
+    }
+    if (targets.size > 0) {
+        if (env_js_1.isDev) {
+            logger_js_1.logger.info(`📦 Loaded ${targets.size} Swift package targets`);
+        }
+        return { targets };
+    }
+    return null;
+}
+// ============================================================================
+// BUNDLED CONFIG LOADER
+// ============================================================================
+/** Load all language-specific configs once for an ingestion run. */
+async function loadImportConfigs(repoRoot) {
+    const csharpScan = await scanCSharpProject(repoRoot);
+    return {
+        tsconfigPaths: await loadTsconfigPaths(repoRoot),
+        goModule: await loadGoModulePath(repoRoot),
+        composerConfig: await loadComposerConfig(repoRoot),
+        swiftPackageConfig: await loadSwiftPackageConfig(repoRoot),
+        csharpConfigs: csharpScan.configs,
+        csharpNamespaces: csharpScanToEvidence(csharpScan),
+    };
+}

package/dist/core/code/engine/core/ingestion/language-provider.js

@@ -0,0 +1,25 @@
+"use strict";
+/**
+ * Language Provider interface — the complete capability contract for a supported language.
+ *
+ * Each language implements this interface in a single file under `languages/`.
+ * The pipeline accesses all per-language behavior through this interface.
+ *
+ * Design pattern: Strategy pattern with compile-time exhaustiveness.
+ * The providers table in `languages/index.ts` uses `satisfies Record<SupportedLanguages, LanguageProvider>`
+ * so adding a language to the enum without creating a provider is a compiler error.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defineLanguage = defineLanguage;
+const DEFAULTS = {
+    mroStrategy: 'first-wins',
+};
+/** Define a language provider — required fields must be supplied, optional fields get sensible defaults. */
+function defineLanguage(config) {
+    const builtIns = config.builtInNames;
+    return {
+        ...DEFAULTS,
+        ...config,
+        isBuiltInName: builtIns ? (name) => builtIns.has(name) : () => false,
+    };
+}