cgraphx 2.0.1 → 2.0.3

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

@@ -0,0 +1,112 @@
+"use strict";
+/**
+ * JVM import resolution — internal helpers (Java + Kotlin).
+ *
+ * Strategies live in configs/jvm.ts.
+ * This file contains shared helpers for wildcard/member resolution
+ * and the Kotlin wildcard preprocessor.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.appendKotlinWildcard = exports.KOTLIN_EXTENSIONS = void 0;
+exports.resolveJvmWildcard = resolveJvmWildcard;
+exports.resolveJvmMemberImport = resolveJvmMemberImport;
+/** Kotlin file extensions for JVM resolver reuse */
+exports.KOTLIN_EXTENSIONS = ['.kt', '.kts'];
+/**
+ * Append .* to a Kotlin import path if the AST has a wildcard_import sibling node.
+ * Pure function — returns a new string without mutating the input.
+ */
+const appendKotlinWildcard = (importPath, importNode) => {
+    for (let i = 0; i < importNode.childCount; i++) {
+        if (importNode.child(i)?.type === 'wildcard_import') {
+            return importPath.endsWith('.*') ? importPath : `${importPath}.*`;
+        }
+    }
+    return importPath;
+};
+exports.appendKotlinWildcard = appendKotlinWildcard;
+/**
+ * Resolve a JVM wildcard import (com.example.*) to all matching files.
+ * Works for both Java (.java) and Kotlin (.kt, .kts).
+ */
+function resolveJvmWildcard(importPath, normalizedFileList, allFileList, extensions, index) {
+    // "com.example.util.*" -> "com/example/util"
+    const packagePath = importPath.slice(0, -2).replace(/\./g, '/');
+    if (index) {
+        const candidates = extensions.flatMap((ext) => index.getFilesInDir(packagePath, ext));
+        // Filter to only direct children (no subdirectories)
+        const packageSuffix = '/' + packagePath + '/';
+        const packagePrefix = packagePath + '/';
+        return candidates.filter((f) => {
+            const normalized = f.replace(/\\/g, '/');
+            // Match both nested (src/models/User.kt) and root-level (models/User.kt) packages
+            let afterPkg;
+            const idx = normalized.lastIndexOf(packageSuffix);
+            if (idx >= 0) {
+                afterPkg = normalized.substring(idx + packageSuffix.length);
+            }
+            else if (normalized.startsWith(packagePrefix)) {
+                afterPkg = normalized.substring(packagePrefix.length);
+            }
+            else {
+                return false;
+            }
+            return !afterPkg.includes('/');
+        });
+    }
+    // Fallback: linear scan
+    const packageSuffix = '/' + packagePath + '/';
+    const packagePrefix = packagePath + '/';
+    const matches = [];
+    for (let i = 0; i < normalizedFileList.length; i++) {
+        const normalized = normalizedFileList[i];
+        if (!extensions.some((ext) => normalized.endsWith(ext)))
+            continue;
+        // Match both nested (src/models/User.kt) and root-level (models/User.kt) packages
+        let afterPackage = null;
+        if (normalized.includes(packageSuffix)) {
+            afterPackage = normalized.substring(normalized.lastIndexOf(packageSuffix) + packageSuffix.length);
+        }
+        else if (normalized.startsWith(packagePrefix)) {
+            afterPackage = normalized.substring(packagePrefix.length);
+        }
+        if (afterPackage !== null && !afterPackage.includes('/')) {
+            matches.push(allFileList[i]);
+        }
+    }
+    return matches;
+}
+/**
+ * Try to resolve a JVM member/static import by stripping the member name.
+ * Java: "com.example.Constants.VALUE" -> resolve "com.example.Constants"
+ * Kotlin: "com.example.Constants.VALUE" -> resolve "com.example.Constants"
+ */
+function resolveJvmMemberImport(importPath, normalizedFileList, allFileList, extensions, index) {
+    // Member imports: com.example.Constants.VALUE or com.example.Constants.*
+    // The last segment is a member name if it starts with lowercase, is ALL_CAPS, or is a wildcard
+    const segments = importPath.split('.');
+    if (segments.length < 3)
+        return null;
+    const lastSeg = segments[segments.length - 1];
+    if (lastSeg === '*' || /^[a-z]/.test(lastSeg) || /^[A-Z_]+$/.test(lastSeg)) {
+        const classPath = segments.slice(0, -1).join('/');
+        for (const ext of extensions) {
+            const classSuffix = classPath + ext;
+            if (index) {
+                const result = index.get(classSuffix) || index.getInsensitive(classSuffix);
+                if (result)
+                    return result;
+            }
+            else {
+                const fullSuffix = '/' + classSuffix;
+                for (let i = 0; i < normalizedFileList.length; i++) {
+                    if (normalizedFileList[i].endsWith(fullSuffix) ||
+                        normalizedFileList[i].toLowerCase().endsWith(fullSuffix.toLowerCase())) {
+                        return allFileList[i];
+                    }
+                }
+            }
+        }
+    }
+    return null;
+}

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

@@ -0,0 +1,80 @@
+"use strict";
+/**
+ * PHP PSR-4 import resolution — internal helpers.
+ *
+ * Strategy lives in configs/php.ts.
+ * This file contains the shared helper for PSR-4 resolution via composer.json.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolvePhpImportInternal = resolvePhpImportInternal;
+const utils_js_1 = require("./utils.js");
+/** Get or compute the sorted PSR-4 entries (cached after first call). */
+function getSortedPsr4(config) {
+    if (!config.psr4Sorted) {
+        const sorted = [...config.psr4.entries()].sort((a, b) => b[0].length - a[0].length);
+        config.psr4Sorted = sorted;
+    }
+    return config.psr4Sorted;
+}
+/**
+ * Resolve a PHP use-statement import path using PSR-4 mappings (low-level helper).
+ * e.g. "App\Http\Controllers\UserController" -> "app/Http/Controllers/UserController.php"
+ *
+ * For function/constant imports (use function App\Models\getUser), the last
+ * segment is the symbol name, not a class name, so it may not map directly to
+ * a file. When PSR-4 class-style resolution fails, we fall back to scanning
+ * .php files in the namespace directory.
+ *
+ * NOTE: The function-import fallback returns the first matching .php file in the
+ * namespace directory. When multiple files exist in the same namespace directory,
+ * resolution is non-deterministic (depends on Set/index iteration order). This is
+ * a known limitation — PHP function imports cannot be resolved to a specific file
+ * without parsing all candidate files.
+ */
+function resolvePhpImportInternal(importPath, composerConfig, allFiles, normalizedFileList, allFileList, index) {
+    // Normalize: replace backslashes with forward slashes
+    const normalized = importPath.replace(/\\/g, '/');
+    // Reject path traversal attempts (defense-in-depth — walker whitelist also prevents this)
+    if (normalized.includes('..'))
+        return null;
+    if (composerConfig) {
+        const sorted = getSortedPsr4(composerConfig);
+        for (const [nsPrefix, dirPrefix] of sorted) {
+            const nsPrefixSlash = nsPrefix.replace(/\\/g, '/');
+            if (normalized.startsWith(nsPrefixSlash + '/') || normalized === nsPrefixSlash) {
+                const remainder = normalized.slice(nsPrefixSlash.length).replace(/^\//, '');
+                // 1. Try class-style PSR-4: full path → file (e.g. App\Models\User → app/Models/User.php)
+                const filePath = dirPrefix + (remainder ? '/' + remainder : '') + '.php';
+                if (allFiles.has(filePath))
+                    return filePath;
+                if (index) {
+                    const result = index.getInsensitive(filePath);
+                    if (result)
+                        return result;
+                }
+                // 2. Function/constant fallback: strip last segment (symbol name), scan namespace directory.
+                //    e.g. App\Models\getUser → directory app/Models/, find first .php file in that dir.
+                const lastSlash = remainder.lastIndexOf('/');
+                const nsDir = lastSlash >= 0 ? dirPrefix + '/' + remainder.slice(0, lastSlash) : dirPrefix;
+                // Prefer SuffixIndex directory lookup (O(log n + matches)) over linear scan
+                if (index) {
+                    const candidates = index.getFilesInDir(nsDir, '.php');
+                    if (candidates.length > 0)
+                        return candidates[0];
+                }
+                // Fallback: linear scan (only when SuffixIndex unavailable)
+                const nsDirPrefix = nsDir.endsWith('/') ? nsDir : nsDir + '/';
+                for (const f of allFiles) {
+                    if (f.startsWith(nsDirPrefix) &&
+                        f.endsWith('.php') &&
+                        !f.slice(nsDirPrefix.length).includes('/')) {
+                        return f;
+                    }
+                }
+            }
+        }
+    }
+    // Fallback: suffix matching (works without composer.json)
+    const pathParts = normalized.split('/').filter(Boolean);
+    return (0, utils_js_1.suffixResolve)(pathParts, normalizedFileList, allFileList, index);
+}

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

@@ -0,0 +1,75 @@
+"use strict";
+/**
+ * Python import resolution — PEP 328 relative imports and proximity-based bare imports.
+ * Import system spec: PEP 302 (original), PEP 451 (current).
+ *
+ * Strategy lives in configs/python.ts.
+ * This file contains the shared internal helper used by the strategy and tests.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolvePythonImportInternal = resolvePythonImportInternal;
+const utils_js_1 = require("./utils.js");
+/**
+ * Resolve a Python import to a file path (low-level helper).
+ *
+ * 1. Relative (PEP 328): `.module`, `..module` — 1 dot = current package, each extra dot goes up one level.
+ * 2. Proximity bare import: static heuristic — checks the importer's own directory first.
+ *    Approximates the common case where co-located files find each other without an installed package.
+ *    Single-segment only — multi-segment (e.g. `os.path`) falls through to suffixResolve.
+ *    Checks package (__init__.py) before module (.py), matching CPython's finder order (PEP 451 §4).
+ *    Coexistence of both is physically impossible (same name = file vs directory), so the order
+ *    only matters for spec compliance.
+ *    Note: implicit namespace packages (Python 3.3+, directory without __init__.py) are not handled.
+ *
+ * Returns null to let the caller fall through to suffixResolve.
+ */
+function resolvePythonImportInternal(currentFile, importPath, allFiles) {
+    // Relative import — PEP 328 (https://peps.python.org/pep-0328/)
+    if (importPath.startsWith('.')) {
+        const dotMatch = importPath.match(/^(\.+)(.*)/);
+        if (!dotMatch)
+            return null;
+        const dotCount = dotMatch[1].length;
+        const modulePart = dotMatch[2];
+        const dirParts = currentFile.split('/').slice(0, -1);
+        // PEP 328: more dots than directory levels → beyond top-level package → invalid
+        if (dotCount - 1 > dirParts.length)
+            return null;
+        for (let i = 1; i < dotCount; i++)
+            dirParts.pop();
+        if (modulePart) {
+            dirParts.push(...modulePart.replace(/\./g, '/').split('/'));
+        }
+        return (0, utils_js_1.tryResolveWithExtensions)(dirParts.join('/'), allFiles);
+    }
+    // Proximity bare import — single-segment only; package before module (PEP 451 §4)
+    const pathLike = importPath.replace(/\./g, '/');
+    if (pathLike.includes('/'))
+        return null;
+    // Normalize for Windows backslashes
+    const importerDir = currentFile.replace(/\\/g, '/').split('/').slice(0, -1).join('/');
+    // Proximity check — only applies when the importer lives in a subdirectory.
+    // Root-level importers (importerDir === '') skip straight to the ancestor
+    // walk below, which handles the root case correctly (prefix becomes '').
+    if (importerDir) {
+        if (allFiles.has(`${importerDir}/${pathLike}/__init__.py`))
+            return `${importerDir}/${pathLike}/__init__.py`;
+        if (allFiles.has(`${importerDir}/${pathLike}.py`))
+            return `${importerDir}/${pathLike}.py`;
+    }
+    // Ancestor directory walk — Python resolves bare imports against sys.path entries,
+    // which typically includes the project root and package directories. Walk up from the
+    // importer's directory to find the module in an ancestor, preferring the closest match.
+    // This prevents cross-language misresolution (e.g., Python `from middleware import X`
+    // resolving to a TypeScript middleware.ts via suffix matching). Issue #417.
+    const dirParts = importerDir.split('/');
+    for (let i = dirParts.length - 1; i >= 0; i--) {
+        const ancestorDir = dirParts.slice(0, i).join('/');
+        const prefix = ancestorDir ? `${ancestorDir}/` : '';
+        if (allFiles.has(`${prefix}${pathLike}/__init__.py`))
+            return `${prefix}${pathLike}/__init__.py`;
+        if (allFiles.has(`${prefix}${pathLike}.py`))
+            return `${prefix}${pathLike}.py`;
+    }
+    return null;
+}

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

@@ -0,0 +1,36 @@
+"use strict";
+/**
+ * Import resolver factory — creates a composable import resolver from
+ * an ordered list of strategies.
+ *
+ * Mirrors the method-extractors/generic.ts and call-extractors/generic.ts
+ * pattern: declare a config per language, produce a runtime resolver via factory.
+ *
+ * Each strategy is tried in order. The first non-null result wins.
+ * A result with an empty `files` array is treated as "handled but unresolved"
+ * (stops the chain without producing import edges).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createImportResolver = createImportResolver;
+/**
+ * Create an ImportResolverFn from a declarative config.
+ *
+ * Chains strategies in declaration order — first non-null result wins.
+ * Returns null only if every strategy returns null.
+ *
+ * Error behaviour: if a strategy throws, the error propagates immediately
+ * and remaining strategies are not tried.  Strategies are expected to be
+ * pure data transforms that never throw; any unexpected exception indicates
+ * a bug in the strategy implementation.
+ */
+function createImportResolver(config) {
+    const { strategies } = config;
+    return (rawImportPath, filePath, ctx) => {
+        for (const strategy of strategies) {
+            const result = strategy(rawImportPath, filePath, ctx);
+            if (result)
+                return result;
+        }
+        return null;
+    };
+}

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

@@ -0,0 +1,20 @@
+"use strict";
+/**
+ * Ruby require/require_relative import resolution — internal helpers.
+ *
+ * Strategy lives in configs/ruby.ts.
+ * This file only contains the low-level helper used by the strategy.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveRubyImportInternal = resolveRubyImportInternal;
+const utils_js_1 = require("./utils.js");
+/**
+ * Resolve a Ruby require/require_relative path to a matching .rb file (low-level helper).
+ *
+ * require_relative paths are pre-normalized to './' prefix by the caller.
+ * require paths use suffix matching (gem-style paths like 'json', 'net/http').
+ */
+function resolveRubyImportInternal(importPath, normalizedFileList, allFileList, index) {
+    const pathParts = importPath.replace(/^\.\//, '').split('/').filter(Boolean);
+    return (0, utils_js_1.suffixResolve)(pathParts, normalizedFileList, allFileList, index);
+}

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

@@ -0,0 +1,79 @@
+"use strict";
+/**
+ * Rust module import resolution — internal helpers.
+ *
+ * Strategy lives in configs/rust.ts.
+ * This file contains shared helpers used by the strategy and standard.ts.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveRustImportInternal = resolveRustImportInternal;
+exports.tryRustModulePath = tryRustModulePath;
+/**
+ * Resolve Rust use-path to a file (low-level helper).
+ * Handles crate::, super::, self:: prefixes and :: path separators.
+ */
+function resolveRustImportInternal(currentFile, importPath, allFiles) {
+    let rustPath;
+    if (importPath.startsWith('crate::')) {
+        // crate:: resolves from src/ directory (standard Rust layout)
+        rustPath = importPath.slice(7).replace(/::/g, '/');
+        // Try from src/ (standard layout)
+        const fromSrc = tryRustModulePath('src/' + rustPath, allFiles);
+        if (fromSrc)
+            return fromSrc;
+        // Try from repo root (non-standard)
+        const fromRoot = tryRustModulePath(rustPath, allFiles);
+        if (fromRoot)
+            return fromRoot;
+        return null;
+    }
+    if (importPath.startsWith('super::')) {
+        // super:: = parent directory of current file's module
+        const currentDir = currentFile.split('/').slice(0, -1);
+        currentDir.pop(); // Go up one level for super::
+        rustPath = importPath.slice(7).replace(/::/g, '/');
+        const fullPath = [...currentDir, rustPath].join('/');
+        return tryRustModulePath(fullPath, allFiles);
+    }
+    if (importPath.startsWith('self::')) {
+        // self:: = current module's directory
+        const currentDir = currentFile.split('/').slice(0, -1);
+        rustPath = importPath.slice(6).replace(/::/g, '/');
+        const fullPath = [...currentDir, rustPath].join('/');
+        return tryRustModulePath(fullPath, allFiles);
+    }
+    // Bare path without prefix (e.g., from a use in a nested module)
+    // Convert :: to / and try suffix matching
+    if (importPath.includes('::')) {
+        rustPath = importPath.replace(/::/g, '/');
+        return tryRustModulePath(rustPath, allFiles);
+    }
+    return null;
+}
+/**
+ * Try to resolve a Rust module path to a file.
+ * Tries: path.rs, path/mod.rs, and with the last segment stripped
+ * (last segment might be a symbol name, not a module).
+ */
+function tryRustModulePath(modulePath, allFiles) {
+    // Try direct: path.rs
+    if (allFiles.has(modulePath + '.rs'))
+        return modulePath + '.rs';
+    // Try directory: path/mod.rs
+    if (allFiles.has(modulePath + '/mod.rs'))
+        return modulePath + '/mod.rs';
+    // Try path/lib.rs (for crate root)
+    if (allFiles.has(modulePath + '/lib.rs'))
+        return modulePath + '/lib.rs';
+    // The last segment might be a symbol (function, struct, etc.), not a module.
+    // Strip it and try again.
+    const lastSlash = modulePath.lastIndexOf('/');
+    if (lastSlash > 0) {
+        const parentPath = modulePath.substring(0, lastSlash);
+        if (allFiles.has(parentPath + '.rs'))
+            return parentPath + '.rs';
+        if (allFiles.has(parentPath + '/mod.rs'))
+            return parentPath + '/mod.rs';
+    }
+    return null;
+}

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

@@ -0,0 +1,180 @@
+"use strict";
+/**
+ * Standard import path resolution.
+ * Handles relative imports, path alias rewriting, and generic suffix matching.
+ * Used as the fallback when language-specific resolvers don't match.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveImportPath = exports.RESOLVE_CACHE_CAP = void 0;
+exports.resolveStandard = resolveStandard;
+exports.createStandardStrategy = createStandardStrategy;
+exports.stripJsExtension = stripJsExtension;
+const utils_js_1 = require("./utils.js");
+const rust_js_1 = require("./rust.js");
+const index_js_1 = require("../../../../shared/index.js");
+/** Max entries in the resolve cache. Beyond this, entries are evicted.
+ *  100K entries ≈ 15MB — covers the most common import patterns. */
+exports.RESOLVE_CACHE_CAP = 100_000;
+/**
+ * Resolve an import path to a file path in the repository.
+ *
+ * Language-specific preprocessing is applied before the generic resolution:
+ * - TypeScript/JavaScript: rewrites tsconfig path aliases
+ * - Rust: converts crate::/super::/self:: to relative paths
+ *
+ * Java wildcards and Go package imports are handled by the scope-resolution
+ * phase because they resolve to multiple files.
+ */
+const resolveImportPath = (currentFile, importPath, allFiles, allFileList, normalizedFileList, resolveCache, language, tsconfigPaths, index) => {
+    const cacheKey = `${currentFile}::${importPath}`;
+    if (resolveCache.has(cacheKey))
+        return resolveCache.get(cacheKey) ?? null;
+    const cache = (result) => {
+        // Evict oldest 20% when cap is reached instead of clearing all
+        if (resolveCache.size >= exports.RESOLVE_CACHE_CAP) {
+            const evictCount = Math.floor(exports.RESOLVE_CACHE_CAP * 0.2);
+            const iter = resolveCache.keys();
+            for (let i = 0; i < evictCount; i++) {
+                const key = iter.next().value;
+                if (key !== undefined)
+                    resolveCache.delete(key);
+            }
+        }
+        resolveCache.set(cacheKey, result);
+        return result;
+    };
+    // ---- TypeScript/JavaScript: rewrite path aliases ----
+    if ((language === index_js_1.SupportedLanguages.TypeScript || language === index_js_1.SupportedLanguages.JavaScript) &&
+        tsconfigPaths &&
+        !importPath.startsWith('.')) {
+        for (const [aliasPrefix, targetPrefix] of tsconfigPaths.aliases) {
+            if (importPath.startsWith(aliasPrefix)) {
+                const remainder = importPath.slice(aliasPrefix.length);
+                // Build the rewritten path relative to baseUrl
+                const rewritten = tsconfigPaths.baseUrl === '.'
+                    ? targetPrefix + remainder
+                    : tsconfigPaths.baseUrl + '/' + targetPrefix + remainder;
+                // Try direct resolution from repo root
+                const resolved = (0, utils_js_1.tryResolveWithExtensions)(rewritten, allFiles);
+                if (resolved)
+                    return cache(resolved);
+                // ESM fallback: strip .js/.jsx/.mjs/.cjs and retry with TS equivalents
+                const strippedAlias = stripJsExtension(rewritten);
+                if (strippedAlias !== null) {
+                    const esmResolved = (0, utils_js_1.tryResolveWithExtensions)(strippedAlias, allFiles);
+                    if (esmResolved)
+                        return cache(esmResolved);
+                }
+                // Try suffix matching as fallback
+                const parts = rewritten.split('/').filter(Boolean);
+                const suffixResult = (0, utils_js_1.suffixResolve)(parts, normalizedFileList, allFileList, index);
+                if (suffixResult)
+                    return cache(suffixResult);
+            }
+        }
+    }
+    // ---- Rust: convert module path syntax to file paths ----
+    if (language === index_js_1.SupportedLanguages.Rust) {
+        // Handle grouped imports: use crate::module::{Foo, Bar, Baz}
+        // Extract the prefix path before ::{...} and resolve the module, not the symbols
+        let rustImportPath = importPath;
+        const braceIdx = importPath.indexOf('::{');
+        if (braceIdx !== -1) {
+            rustImportPath = importPath.substring(0, braceIdx);
+        }
+        else if (importPath.startsWith('{') && importPath.endsWith('}')) {
+            // Top-level grouped imports: use {crate::a, crate::b}
+            // Iterate each part and return the first that resolves. This function returns a single
+            // string, so callers that need ALL edges must intercept before reaching here (the
+            // scope-resolution phase handles Rust grouped-import blocks). This fallback
+            // handles any path that reaches resolveImportPath directly.
+            const inner = importPath.slice(1, -1);
+            const parts = inner
+                .split(',')
+                .map((p) => p.trim())
+                .filter(Boolean);
+            for (const part of parts) {
+                const partResult = (0, rust_js_1.resolveRustImportInternal)(currentFile, part, allFiles);
+                if (partResult)
+                    return cache(partResult);
+            }
+            return cache(null);
+        }
+        const rustResult = (0, rust_js_1.resolveRustImportInternal)(currentFile, rustImportPath, allFiles);
+        if (rustResult)
+            return cache(rustResult);
+        // Fall through to generic resolution if Rust-specific didn't match
+    }
+    // ---- Generic relative import resolution (./ and ../) ----
+    const currentDir = currentFile.split('/').slice(0, -1);
+    const parts = importPath.split('/');
+    for (const part of parts) {
+        if (part === '.')
+            continue;
+        if (part === '..') {
+            currentDir.pop();
+        }
+        else {
+            currentDir.push(part);
+        }
+    }
+    const basePath = currentDir.join('/');
+    if (importPath.startsWith('.')) {
+        const resolved = (0, utils_js_1.tryResolveWithExtensions)(basePath, allFiles);
+        if (resolved)
+            return cache(resolved);
+        // TypeScript ESM: imports use .js/.jsx/.mjs/.cjs but source files are
+        // .ts/.tsx/.mts/.cts. Strip the JS-family extension and re-resolve.
+        if (language === index_js_1.SupportedLanguages.TypeScript || language === index_js_1.SupportedLanguages.JavaScript) {
+            const stripped = stripJsExtension(basePath);
+            if (stripped !== null) {
+                return cache((0, utils_js_1.tryResolveWithExtensions)(stripped, allFiles));
+            }
+        }
+        return cache(null);
+    }
+    // ---- Generic package/absolute import resolution (suffix matching) ----
+    // Java wildcards are handled by the scope-resolution phase, not here; this
+    // resolver returns null for `.*` so it never produces a single-file match.
+    if (importPath.endsWith('.*')) {
+        return cache(null);
+    }
+    // C/C++ includes use actual file paths (e.g. "animal.h") — don't convert dots to slashes
+    const isCpp = language === index_js_1.SupportedLanguages.C || language === index_js_1.SupportedLanguages.CPlusPlus;
+    const pathLike = importPath.includes('/') || isCpp ? importPath : importPath.replace(/\./g, '/');
+    const pathParts = pathLike.split('/').filter(Boolean);
+    const resolved = (0, utils_js_1.suffixResolve)(pathParts, normalizedFileList, allFileList, index);
+    return cache(resolved);
+};
+exports.resolveImportPath = resolveImportPath;
+// ============================================================================
+// Per-language dispatch functions (moved from import-resolution.ts)
+// ============================================================================
+/**
+ * Standard single-file resolution (TS/JS/C/C++ and fallback for other languages).
+ * Handles relative imports, tsconfig path aliases, and suffix matching.
+ */
+function resolveStandard(rawImportPath, filePath, ctx, language) {
+    const resolvedPath = (0, exports.resolveImportPath)(filePath, rawImportPath, ctx.allFilePaths, ctx.allFileList, ctx.normalizedFileList, ctx.resolveCache, language, ctx.configs.tsconfigPaths, ctx.index);
+    return resolvedPath ? { kind: 'files', files: [resolvedPath] } : null;
+}
+// ============================================================================
+// Strategy factory — composable hook for ImportResolutionConfig
+// ============================================================================
+/** Create a reusable standard-resolution strategy for a given language. */
+function createStandardStrategy(language) {
+    return (raw, fp, ctx) => resolveStandard(raw, fp, ctx, language);
+}
+// ============================================================================
+// ESM extension helpers
+// ============================================================================
+/** JS-family extensions that TypeScript ESM maps to TS equivalents. */
+const JS_EXTENSION_PATTERN = /\.(js|jsx|mjs|cjs)$/;
+/**
+ * Strip a JS-family extension from a path, returning the stem.
+ * Returns `null` if the path does not end with a JS-family extension.
+ */
+function stripJsExtension(path) {
+    const match = JS_EXTENSION_PATTERN.exec(path);
+    return match ? path.slice(0, -match[0].length) : null;
+}

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

@@ -0,0 +1,7 @@
+"use strict";
+/**
+ * Import resolution types — shared across all per-language resolvers.
+ *
+ * Extracted from import-resolution.ts to co-locate types with their consumers.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });