cgraphx 2.0.1 → 2.0.3

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

@@ -0,0 +1,59 @@
+"use strict";
+/**
+ * Dart import resolution config.
+ * SDK/package strategy first, then relative import strategy (with ./ prepending).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dartImportConfig = exports.dartRelativeStrategy = exports.dartPackageStrategy = void 0;
+const index_js_1 = require("../../../../../shared/index.js");
+const standard_js_1 = require("../standard.js");
+/**
+ * Dart SDK and package: import strategy.
+ * Absorbs dart: SDK imports and external packages (returns empty result to stop chain).
+ * Returns null for relative imports to let the next strategy handle them.
+ */
+const dartPackageStrategy = (rawImportPath, _filePath, ctx) => {
+    // Strip surrounding quotes from configurable_uri capture
+    const stripped = rawImportPath.replace(/^['"]|['"]$/g, '');
+    // Skip dart: SDK imports (dart:async, dart:io, etc.)
+    if (stripped.startsWith('dart:'))
+        return { kind: 'files', files: [] };
+    // Local package: imports → resolve to lib/<path>
+    if (stripped.startsWith('package:')) {
+        const slashIdx = stripped.indexOf('/');
+        if (slashIdx === -1)
+            return { kind: 'files', files: [] };
+        const relPath = stripped.slice(slashIdx + 1);
+        const candidates = [`lib/${relPath}`, relPath];
+        const files = [];
+        for (const candidate of candidates) {
+            for (const fp of ctx.allFileList) {
+                if (fp.endsWith('/' + candidate) || fp === candidate) {
+                    files.push(fp);
+                    break;
+                }
+            }
+            if (files.length > 0)
+                break;
+        }
+        if (files.length > 0)
+            return { kind: 'files', files };
+        return { kind: 'files', files: [] }; // external package
+    }
+    return null;
+};
+exports.dartPackageStrategy = dartPackageStrategy;
+/**
+ * Dart relative import strategy — prepends "./" for bare relative paths,
+ * then delegates to standard resolution.
+ */
+const dartRelativeStrategy = (rawImportPath, filePath, ctx) => {
+    const stripped = rawImportPath.replace(/^['"]|['"]$/g, '');
+    const relPath = stripped.startsWith('.') ? stripped : './' + stripped;
+    return (0, standard_js_1.resolveStandard)(relPath, filePath, ctx, index_js_1.SupportedLanguages.Dart);
+};
+exports.dartRelativeStrategy = dartRelativeStrategy;
+exports.dartImportConfig = {
+    language: index_js_1.SupportedLanguages.Dart,
+    strategies: [exports.dartPackageStrategy, exports.dartRelativeStrategy],
+};

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

@@ -0,0 +1,30 @@
+"use strict";
+/**
+ * Go import resolution config.
+ * Go-specific package strategy (go.mod), then standard fallback.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.goImportConfig = exports.goPackageStrategy = void 0;
+const index_js_1 = require("../../../../../shared/index.js");
+const standard_js_1 = require("../standard.js");
+const go_js_1 = require("../go.js");
+/** Go-specific package resolution strategy — resolves go.mod-based package imports. */
+const goPackageStrategy = (rawImportPath, _filePath, ctx) => {
+    const goModule = ctx.configs.goModule;
+    if (goModule && rawImportPath.startsWith(goModule.modulePath)) {
+        const pkgSuffix = (0, go_js_1.resolveGoPackageDir)(rawImportPath, goModule);
+        if (pkgSuffix) {
+            const pkgFiles = (0, go_js_1.resolveGoPackage)(rawImportPath, goModule, ctx.normalizedFileList, ctx.allFileList);
+            if (pkgFiles.length > 0) {
+                return { kind: 'package', files: pkgFiles, dirSuffix: pkgSuffix };
+            }
+        }
+        // Fall through if no files found (package might be external)
+    }
+    return null;
+};
+exports.goPackageStrategy = goPackageStrategy;
+exports.goImportConfig = {
+    language: index_js_1.SupportedLanguages.Go,
+    strategies: [exports.goPackageStrategy, (0, standard_js_1.createStandardStrategy)(index_js_1.SupportedLanguages.Go)],
+};

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

@@ -0,0 +1,73 @@
+"use strict";
+/**
+ * Java / Kotlin import resolution configs.
+ * JVM-specific wildcard/member strategy, then standard fallback.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.kotlinImportConfig = exports.javaImportConfig = exports.kotlinJvmStrategy = exports.javaJvmStrategy = void 0;
+const index_js_1 = require("../../../../../shared/index.js");
+const standard_js_1 = require("../standard.js");
+const jvm_js_1 = require("../jvm.js");
+/** Java JVM resolution strategy — wildcard and member import resolution. */
+const javaJvmStrategy = (rawImportPath, _filePath, ctx) => {
+    if (rawImportPath.endsWith('.*')) {
+        const matchedFiles = (0, jvm_js_1.resolveJvmWildcard)(rawImportPath, ctx.normalizedFileList, ctx.allFileList, ['.java'], ctx.index);
+        if (matchedFiles.length > 0)
+            return { kind: 'files', files: matchedFiles };
+    }
+    else {
+        const memberResolved = (0, jvm_js_1.resolveJvmMemberImport)(rawImportPath, ctx.normalizedFileList, ctx.allFileList, ['.java'], ctx.index);
+        if (memberResolved)
+            return { kind: 'files', files: [memberResolved] };
+    }
+    return null;
+};
+exports.javaJvmStrategy = javaJvmStrategy;
+/**
+ * Kotlin JVM resolution strategy — wildcard/member with Java-interop + top-level function imports.
+ */
+const kotlinJvmStrategy = (rawImportPath, _filePath, ctx) => {
+    if (rawImportPath.endsWith('.*')) {
+        const matchedFiles = (0, jvm_js_1.resolveJvmWildcard)(rawImportPath, ctx.normalizedFileList, ctx.allFileList, jvm_js_1.KOTLIN_EXTENSIONS, ctx.index);
+        if (matchedFiles.length === 0) {
+            const javaMatches = (0, jvm_js_1.resolveJvmWildcard)(rawImportPath, ctx.normalizedFileList, ctx.allFileList, ['.java'], ctx.index);
+            if (javaMatches.length > 0)
+                return { kind: 'files', files: javaMatches };
+        }
+        if (matchedFiles.length > 0)
+            return { kind: 'files', files: matchedFiles };
+    }
+    else {
+        let memberResolved = (0, jvm_js_1.resolveJvmMemberImport)(rawImportPath, ctx.normalizedFileList, ctx.allFileList, jvm_js_1.KOTLIN_EXTENSIONS, ctx.index);
+        if (!memberResolved) {
+            memberResolved = (0, jvm_js_1.resolveJvmMemberImport)(rawImportPath, ctx.normalizedFileList, ctx.allFileList, ['.java'], ctx.index);
+        }
+        if (memberResolved)
+            return { kind: 'files', files: [memberResolved] };
+        // Kotlin: top-level function imports (e.g. import models.getUser) have only 2 segments,
+        // which resolveJvmMemberImport skips (requires >=3). Fall back to package-directory scan
+        // for lowercase last segments (function/property imports). Uppercase last segments
+        // (class imports like models.User) fall through to standard suffix resolution.
+        const segments = rawImportPath.split('.');
+        const lastSeg = segments[segments.length - 1];
+        if (segments.length >= 2 && lastSeg[0] && lastSeg[0] === lastSeg[0].toLowerCase()) {
+            const pkgWildcard = segments.slice(0, -1).join('.') + '.*';
+            let dirFiles = (0, jvm_js_1.resolveJvmWildcard)(pkgWildcard, ctx.normalizedFileList, ctx.allFileList, jvm_js_1.KOTLIN_EXTENSIONS, ctx.index);
+            if (dirFiles.length === 0) {
+                dirFiles = (0, jvm_js_1.resolveJvmWildcard)(pkgWildcard, ctx.normalizedFileList, ctx.allFileList, ['.java'], ctx.index);
+            }
+            if (dirFiles.length > 0)
+                return { kind: 'files', files: dirFiles };
+        }
+    }
+    return null;
+};
+exports.kotlinJvmStrategy = kotlinJvmStrategy;
+exports.javaImportConfig = {
+    language: index_js_1.SupportedLanguages.Java,
+    strategies: [exports.javaJvmStrategy, (0, standard_js_1.createStandardStrategy)(index_js_1.SupportedLanguages.Java)],
+};
+exports.kotlinImportConfig = {
+    language: index_js_1.SupportedLanguages.Kotlin,
+    strategies: [exports.kotlinJvmStrategy, (0, standard_js_1.createStandardStrategy)(index_js_1.SupportedLanguages.Kotlin)],
+};

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

@@ -0,0 +1,19 @@
+"use strict";
+/**
+ * PHP import resolution config.
+ * PSR-4 strategy via composer.json — no standard fallback (PSR-4 includes its own suffix matching).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.phpImportConfig = exports.phpPsr4Strategy = void 0;
+const index_js_1 = require("../../../../../shared/index.js");
+const php_js_1 = require("../php.js");
+/** PHP PSR-4 resolution strategy via composer.json autoload mappings. */
+const phpPsr4Strategy = (rawImportPath, _filePath, ctx) => {
+    const resolved = (0, php_js_1.resolvePhpImportInternal)(rawImportPath, ctx.configs.composerConfig, ctx.allFilePaths, ctx.normalizedFileList, ctx.allFileList, ctx.index);
+    return resolved ? { kind: 'files', files: [resolved] } : null;
+};
+exports.phpPsr4Strategy = phpPsr4Strategy;
+exports.phpImportConfig = {
+    language: index_js_1.SupportedLanguages.PHP,
+    strategies: [exports.phpPsr4Strategy],
+};

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

@@ -0,0 +1,45 @@
+"use strict";
+/**
+ * Python import resolution config.
+ * PEP 328 relative + proximity-based strategy, then standard fallback.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pythonImportConfig = exports.pythonImportStrategy = void 0;
+const index_js_1 = require("../../../../../shared/index.js");
+const standard_js_1 = require("../standard.js");
+const python_js_1 = require("../python.js");
+/**
+ * Python import resolution strategy — PEP 328 relative + proximity-based bare imports.
+ * Returns null to continue chain for non-relative imports.
+ * Absorbs unresolved relative imports (returns empty result to stop the chain).
+ */
+const pythonImportStrategy = (rawImportPath, filePath, ctx) => {
+    const resolved = (0, python_js_1.resolvePythonImportInternal)(filePath, rawImportPath, ctx.allFilePaths);
+    if (resolved) {
+        ctx.resolveCache.set(`${filePath}::${rawImportPath}`, resolved);
+        return { kind: 'files', files: [resolved] };
+    }
+    // PEP 328: unresolved relative imports should not fall through to suffix matching
+    if (rawImportPath.startsWith('.'))
+        return { kind: 'files', files: [] };
+    // External dotted imports like `django.apps` should not fall through to generic
+    // suffix matching when the repo has unrelated local files such as `accounts/apps.py`.
+    // Keep suffix fallback only when the leading segment appears somewhere in-repo,
+    // which preserves existing internal absolute-import behavior like `accounts.models`.
+    const pathLike = rawImportPath.replace(/\./g, '/');
+    if (pathLike.includes('/')) {
+        const [leadingSegment] = pathLike.split('/').filter(Boolean);
+        const hasRepoCandidate = !!leadingSegment &&
+            (ctx.index.get(`${leadingSegment}.py`) !== undefined ||
+                ctx.index.get(`${leadingSegment}/__init__.py`) !== undefined ||
+                ctx.index.getFilesInDir(leadingSegment, '.py').length > 0);
+        if (!hasRepoCandidate)
+            return { kind: 'files', files: [] };
+    }
+    return null;
+};
+exports.pythonImportStrategy = pythonImportStrategy;
+exports.pythonImportConfig = {
+    language: index_js_1.SupportedLanguages.Python,
+    strategies: [exports.pythonImportStrategy, (0, standard_js_1.createStandardStrategy)(index_js_1.SupportedLanguages.Python)],
+};

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

@@ -0,0 +1,20 @@
+"use strict";
+/**
+ * Ruby import resolution config.
+ * Require/require_relative suffix matching — no standard fallback.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rubyImportConfig = exports.rubyRequireStrategy = void 0;
+const index_js_1 = require("../../../../../shared/index.js");
+const utils_js_1 = require("../utils.js");
+/** Ruby require/require_relative resolution strategy. */
+const rubyRequireStrategy = (rawImportPath, _filePath, ctx) => {
+    const pathParts = rawImportPath.replace(/^\.\//, '').split('/').filter(Boolean);
+    const resolved = (0, utils_js_1.suffixResolve)(pathParts, ctx.normalizedFileList, ctx.allFileList, ctx.index);
+    return resolved ? { kind: 'files', files: [resolved] } : null;
+};
+exports.rubyRequireStrategy = rubyRequireStrategy;
+exports.rubyImportConfig = {
+    language: index_js_1.SupportedLanguages.Ruby,
+    strategies: [exports.rubyRequireStrategy],
+};

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

@@ -0,0 +1,58 @@
+"use strict";
+/**
+ * Rust import resolution config.
+ * Rust module strategy (grouped imports, crate/super/self paths), then standard fallback.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rustImportConfig = exports.rustModuleStrategy = void 0;
+const index_js_1 = require("../../../../../shared/index.js");
+const standard_js_1 = require("../standard.js");
+const rust_js_1 = require("../rust.js");
+/** Rust module resolution strategy — handles grouped imports and crate/super/self paths. */
+const rustModuleStrategy = (rawImportPath, filePath, ctx) => {
+    // Top-level grouped: use {crate::a, crate::b}
+    if (rawImportPath.startsWith('{') && rawImportPath.endsWith('}')) {
+        const inner = rawImportPath.slice(1, -1);
+        const parts = inner
+            .split(',')
+            .map((p) => p.trim())
+            .filter(Boolean);
+        const resolved = [];
+        for (const part of parts) {
+            const r = (0, rust_js_1.resolveRustImportInternal)(filePath, part, ctx.allFilePaths);
+            if (r)
+                resolved.push(r);
+        }
+        return resolved.length > 0 ? { kind: 'files', files: resolved } : null;
+    }
+    // Scoped grouped: use crate::models::{User, Repo}
+    const braceIdx = rawImportPath.indexOf('::{');
+    if (braceIdx !== -1 && rawImportPath.endsWith('}')) {
+        const pathPrefix = rawImportPath.substring(0, braceIdx);
+        const braceContent = rawImportPath.substring(braceIdx + 3, rawImportPath.length - 1);
+        const items = braceContent
+            .split(',')
+            .map((s) => s.trim())
+            .filter(Boolean);
+        const resolved = [];
+        for (const item of items) {
+            // Handle `use crate::models::{User, Repo as R}` — strip alias for resolution
+            const itemName = item.includes(' as ') ? item.split(' as ')[0].trim() : item;
+            const r = (0, rust_js_1.resolveRustImportInternal)(filePath, `${pathPrefix}::${itemName}`, ctx.allFilePaths);
+            if (r)
+                resolved.push(r);
+        }
+        if (resolved.length > 0)
+            return { kind: 'files', files: resolved };
+        // Fallback: resolve the prefix path itself (e.g. crate::models -> models.rs)
+        const prefixResult = (0, rust_js_1.resolveRustImportInternal)(filePath, pathPrefix, ctx.allFilePaths);
+        if (prefixResult)
+            return { kind: 'files', files: [prefixResult] };
+    }
+    return null;
+};
+exports.rustModuleStrategy = rustModuleStrategy;
+exports.rustImportConfig = {
+    language: index_js_1.SupportedLanguages.Rust,
+    strategies: [exports.rustModuleStrategy, (0, standard_js_1.createStandardStrategy)(index_js_1.SupportedLanguages.Rust)],
+};

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

@@ -0,0 +1,94 @@
+"use strict";
+/**
+ * Swift import resolution config.
+ * Package.swift target map strategy — no standard fallback (unresolved = external framework).
+ *
+ * ## Performance (anti-O(imports × files))
+ *
+ * The previous implementation rescanned the whole `normalizedFileList`
+ * on every import to collect the `.swift` files under the requested
+ * target's directory — O(imports × files) per run, the exact hot path
+ * fixed for Python in PR #1918. We now build a `target → files` index
+ * ONCE per run, memoized on the stable `allFileList` array reference
+ * (the same `ResolveCtx` — and therefore the same array — is passed to
+ * every strategy invocation, per `import-processor`'s build-once
+ * context). Lookup per import is then O(1).
+ *
+ * Behavior is preserved bit-for-bit: a file is attributed to a target
+ * iff its **forward-slash (backslash-normalized), case-sensitive** path
+ * starts with `<targetDir>/`, matching the old
+ * `normalizedFileList[i].startsWith(targetDir + '/')` comparison
+ * (`normalizedFileList` is only backslash→forward-slash normalized — NOT
+ * lowercased — so the match is case-sensitive); the returned paths are
+ * the original-case `allFileList` entries; and the per-target file ORDER
+ * follows `allFileList`, so the emitted `{ kind: 'files', files }` set and
+ * ordering are identical to the old scan.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.swiftImportConfig = exports.swiftPackageStrategy = void 0;
+const index_js_1 = require("../../../../../shared/index.js");
+/**
+ * Memoized on the `allFileList` array identity. `import-processor` builds
+ * the `ResolveCtx` once per run and threads the same object (and the same
+ * `allFileList`) through every strategy call, so the WeakMap is keyed on a
+ * stable reference and the index is built once — not once per import. A
+ * fresh run produces a fresh array → a fresh index, so cross-run staleness
+ * is impossible.
+ */
+const SWIFT_TARGET_INDEX_CACHE = new WeakMap();
+function getSwiftTargetIndex(ctx, targets) {
+    const key = ctx.allFileList;
+    const cached = SWIFT_TARGET_INDEX_CACHE.get(key);
+    if (cached !== undefined)
+        return cached;
+    // Pre-compute each target's directory prefix once (original case, to
+    // match the legacy comparison against the forward-slash-normalized,
+    // case-sensitive file list — see module docstring).
+    const targetPrefixes = [];
+    const byTarget = new Map();
+    for (const [name, dir] of targets) {
+        targetPrefixes.push({ name, prefix: dir + '/' });
+        byTarget.set(name, []);
+    }
+    // Single pass over the file list. `normalizedFileList` is forward-slash
+    // (backslash-normalized), case-sensitive, and index-aligned with
+    // `allFileList`; attribute the original-case path to every target whose
+    // prefix the normalized path starts with (a file under a nested target
+    // dir can legitimately belong to multiple configured targets — the
+    // legacy per-import scan would have returned it for each).
+    for (let i = 0; i < ctx.allFileList.length; i++) {
+        const norm = ctx.normalizedFileList[i];
+        if (!norm.endsWith('.swift'))
+            continue;
+        for (const { name, prefix } of targetPrefixes) {
+            if (norm.startsWith(prefix)) {
+                byTarget.get(name).push(ctx.allFileList[i]);
+            }
+        }
+    }
+    const index = { byTarget };
+    SWIFT_TARGET_INDEX_CACHE.set(key, index);
+    return index;
+}
+/** Swift Package.swift target map resolution strategy. */
+const swiftPackageStrategy = (rawImportPath, _filePath, ctx) => {
+    const swiftPackageConfig = ctx.configs.swiftPackageConfig;
+    if (swiftPackageConfig) {
+        // Only the targets map is needed; build the index lazily so repos
+        // without a Package.swift config pay nothing.
+        if (swiftPackageConfig.targets.has(rawImportPath)) {
+            const index = getSwiftTargetIndex(ctx, swiftPackageConfig.targets);
+            const files = index.byTarget.get(rawImportPath);
+            if (files !== undefined && files.length > 0) {
+                // Copy so callers can't mutate the cached index bucket.
+                return { kind: 'files', files: [...files] };
+            }
+        }
+    }
+    return null; // External framework (Foundation, UIKit, etc.)
+};
+exports.swiftPackageStrategy = swiftPackageStrategy;
+exports.swiftImportConfig = {
+    language: index_js_1.SupportedLanguages.Swift,
+    strategies: [exports.swiftPackageStrategy],
+};

package/dist/core/code/engine/core/ingestion/import-resolvers/configs/typescript-javascript.js

@@ -0,0 +1,26 @@
+"use strict";
+/**
+ * TypeScript / JavaScript / Vue import resolution configs.
+ * All use standard resolution — TS/JS with tsconfig path aliases,
+ * Vue delegates to TypeScript's resolver.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.vueImportConfig = exports.javascriptImportConfig = exports.typescriptImportConfig = void 0;
+const index_js_1 = require("../../../../../shared/index.js");
+const standard_js_1 = require("../standard.js");
+exports.typescriptImportConfig = {
+    language: index_js_1.SupportedLanguages.TypeScript,
+    strategies: [(0, standard_js_1.createStandardStrategy)(index_js_1.SupportedLanguages.TypeScript)],
+};
+exports.javascriptImportConfig = {
+    language: index_js_1.SupportedLanguages.JavaScript,
+    strategies: [(0, standard_js_1.createStandardStrategy)(index_js_1.SupportedLanguages.JavaScript)],
+};
+// Vue SFCs are preprocessed into TypeScript upstream of import resolution,
+// so the resolver intentionally runs as TypeScript. `language: Vue` here is
+// documentation-only metadata (see `ImportResolutionConfig.language` JSDoc
+// and ARCHITECTURE.md §Vue); it is not consumed by `createImportResolver`.
+exports.vueImportConfig = {
+    language: index_js_1.SupportedLanguages.Vue,
+    strategies: [(0, standard_js_1.createStandardStrategy)(index_js_1.SupportedLanguages.TypeScript)],
+};

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

@@ -0,0 +1,128 @@
+"use strict";
+/**
+ * C# namespace import resolution — internal helpers.
+ *
+ * Strategy lives in configs/csharp.ts.
+ * This file contains shared helpers for namespace-based resolution.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveCSharpImportInternal = resolveCSharpImportInternal;
+exports.resolveCSharpNamespaceDir = resolveCSharpNamespaceDir;
+const utils_js_1 = require("./utils.js");
+const csharp_namespace_gate_js_1 = require("../csharp-namespace-gate.js");
+/**
+ * Resolve a C# using-directive import path to matching .cs files (low-level helper).
+ * Tries single-file match first, then directory match for namespace imports.
+ *
+ * The final unanchored suffix fallback is gated on `evidence` so BCL usings
+ * (e.g. `System.Threading.Tasks`) can't match a coincidentally-named local
+ * file (#1881). When `evidence` is omitted the fallback stays permissive.
+ */
+function resolveCSharpImportInternal(importPath, csharpConfigs, normalizedFileList, allFileList, index, evidence) {
+    const namespacePath = importPath.replace(/\./g, '/');
+    const results = [];
+    for (const config of csharpConfigs) {
+        const nsPath = config.rootNamespace.replace(/\./g, '/');
+        let relative;
+        if (namespacePath.startsWith(nsPath + '/')) {
+            relative = namespacePath.slice(nsPath.length + 1);
+        }
+        else if (namespacePath === nsPath) {
+            // The import IS the root namespace — resolve to all .cs files in project root
+            relative = '';
+        }
+        else {
+            continue;
+        }
+        const dirPrefix = config.projectDir
+            ? relative
+                ? config.projectDir + '/' + relative
+                : config.projectDir
+            : relative;
+        // 1. Try as single file: relative.cs (e.g., "Models/DlqMessage.cs")
+        if (relative) {
+            const candidate = dirPrefix + '.cs';
+            if (index) {
+                const result = index.get(candidate) || index.getInsensitive(candidate);
+                if (result)
+                    return [result];
+            }
+            // Also try suffix match
+            const suffixResult = index?.get(relative + '.cs') || index?.getInsensitive(relative + '.cs');
+            if (suffixResult)
+                return [suffixResult];
+        }
+        // 2. Try as directory: all .cs files directly inside (namespace import)
+        if (index) {
+            const dirFiles = index.getFilesInDir(dirPrefix, '.cs');
+            for (const f of dirFiles) {
+                const normalized = f.replace(/\\/g, '/');
+                // Check it's a direct child by finding the dirPrefix and ensuring no deeper slashes
+                const prefixIdx = normalized.indexOf(dirPrefix + '/');
+                if (prefixIdx < 0)
+                    continue;
+                const afterDir = normalized.substring(prefixIdx + dirPrefix.length + 1);
+                if (!afterDir.includes('/')) {
+                    results.push(f);
+                }
+            }
+            if (results.length > 0)
+                return results;
+        }
+        // 3. Linear scan fallback for directory matching
+        if (results.length === 0) {
+            const dirTrail = dirPrefix + '/';
+            for (let i = 0; i < normalizedFileList.length; i++) {
+                const normalized = normalizedFileList[i];
+                if (!normalized.endsWith('.cs'))
+                    continue;
+                const prefixIdx = normalized.indexOf(dirTrail);
+                if (prefixIdx < 0)
+                    continue;
+                const afterDir = normalized.substring(prefixIdx + dirTrail.length);
+                if (!afterDir.includes('/')) {
+                    results.push(allFileList[i]);
+                }
+            }
+            if (results.length > 0)
+                return results;
+        }
+    }
+    // Fallback: suffix matching without namespace stripping (single file).
+    // Gated on in-repo declared-namespace evidence (#1881).
+    if (!(0, csharp_namespace_gate_js_1.csharpSuffixFallbackAllowed)(importPath, evidence)) {
+        return [];
+    }
+    const pathParts = namespacePath.split('/').filter(Boolean);
+    const fallback = (0, utils_js_1.suffixResolve)(pathParts, normalizedFileList, allFileList, index);
+    return fallback ? [fallback] : [];
+}
+/**
+ * Compute the directory suffix for a C# namespace import (for PackageMap).
+ * Returns a suffix like "/ProjectDir/Models/" or null if no config matches.
+ */
+function resolveCSharpNamespaceDir(importPath, csharpConfigs) {
+    const namespacePath = importPath.replace(/\./g, '/');
+    for (const config of csharpConfigs) {
+        const nsPath = config.rootNamespace.replace(/\./g, '/');
+        let relative;
+        if (namespacePath.startsWith(nsPath + '/')) {
+            relative = namespacePath.slice(nsPath.length + 1);
+        }
+        else if (namespacePath === nsPath) {
+            relative = '';
+        }
+        else {
+            continue;
+        }
+        const dirPrefix = config.projectDir
+            ? relative
+                ? config.projectDir + '/' + relative
+                : config.projectDir
+            : relative;
+        if (!dirPrefix)
+            continue;
+        return '/' + dirPrefix + '/';
+    }
+    return null;
+}

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

@@ -0,0 +1,50 @@
+"use strict";
+/**
+ * Go package import resolution — internal helpers.
+ *
+ * Strategy lives in configs/go.ts.
+ * This file contains the shared helpers used by the strategy.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveGoPackageDir = resolveGoPackageDir;
+exports.resolveGoPackage = resolveGoPackage;
+/**
+ * Extract the package directory suffix from a Go import path.
+ * Returns the suffix string (e.g., "/internal/auth/") or null if invalid.
+ */
+function resolveGoPackageDir(importPath, goModule) {
+    if (!importPath.startsWith(goModule.modulePath))
+        return null;
+    const relativePkg = importPath.slice(goModule.modulePath.length + 1);
+    if (!relativePkg)
+        return null;
+    return '/' + relativePkg + '/';
+}
+/**
+ * Resolve a Go internal package import to all .go files in the package directory.
+ * Returns an array of file paths.
+ */
+function resolveGoPackage(importPath, goModule, normalizedFileList, allFileList) {
+    if (!importPath.startsWith(goModule.modulePath))
+        return [];
+    // Strip module path to get relative package path
+    const relativePkg = importPath.slice(goModule.modulePath.length + 1); // e.g., "internal/auth"
+    if (!relativePkg)
+        return [];
+    const pkgSuffix = '/' + relativePkg + '/';
+    const matches = [];
+    for (let i = 0; i < normalizedFileList.length; i++) {
+        // Prepend '/' so paths like "internal/auth/service.go" match suffix "/internal/auth/"
+        const normalized = '/' + normalizedFileList[i];
+        // File must be directly in the package directory (not a subdirectory)
+        if (normalized.includes(pkgSuffix) &&
+            normalized.endsWith('.go') &&
+            !normalized.endsWith('_test.go')) {
+            const afterPkg = normalized.substring(normalized.indexOf(pkgSuffix) + pkgSuffix.length);
+            if (!afterPkg.includes('/')) {
+                matches.push(allFileList[i]);
+            }
+        }
+    }
+    return matches;
+}