@codragraph/cli 1.6.2

package/dist/core/ingestion/import-resolvers/utils.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Shared utilities for import resolution.
+ * Extracted from import-processor.ts to reduce file size.
+ */
+/** All file extensions to try during resolution */
+export declare const EXTENSIONS: string[];
+/**
+ * Try to match a path (with extensions) against the known file set.
+ * Returns the matched file path or null.
+ */
+export declare function tryResolveWithExtensions(basePath: string, allFiles: Set<string>): string | null;
+/**
+ * Build a suffix index for O(1) endsWith lookups.
+ * Maps every possible path suffix to its original file path.
+ * e.g. for "src/com/example/Foo.java":
+ *   "Foo.java" -> "src/com/example/Foo.java"
+ *   "example/Foo.java" -> "src/com/example/Foo.java"
+ *   "com/example/Foo.java" -> "src/com/example/Foo.java"
+ *   etc.
+ */
+export interface SuffixIndex {
+    /** Exact suffix lookup (case-sensitive) */
+    get(suffix: string): string | undefined;
+    /** Case-insensitive suffix lookup */
+    getInsensitive(suffix: string): string | undefined;
+    /** Get all files in a directory suffix */
+    getFilesInDir(dirSuffix: string, extension: string): string[];
+}
+/** Sentinel index that returns no results. Used to release memory after import resolution. */
+export declare const EMPTY_INDEX: SuffixIndex;
+export declare function buildSuffixIndex(normalizedFileList: string[], allFileList: string[]): SuffixIndex;
+/**
+ * Suffix-based resolution using index. O(1) per lookup instead of O(files).
+ */
+export declare function suffixResolve(pathParts: string[], normalizedFileList: string[], allFileList: string[], index?: SuffixIndex): string | null;

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

@@ -0,0 +1,149 @@
+/**
+ * Shared utilities for import resolution.
+ * Extracted from import-processor.ts to reduce file size.
+ */
+/** All file extensions to try during resolution */
+export const EXTENSIONS = [
+    '',
+    // TypeScript/JavaScript
+    '.tsx',
+    '.ts',
+    '.jsx',
+    '.js',
+    '.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',
+    // 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.
+ */
+export function tryResolveWithExtensions(basePath, allFiles) {
+    for (const ext of EXTENSIONS) {
+        const candidate = basePath + ext;
+        if (allFiles.has(candidate))
+            return candidate;
+    }
+    return null;
+}
+const FROZEN_EMPTY_ARRAY = Object.freeze([]);
+/** Sentinel index that returns no results. Used to release memory after import resolution. */
+export const EMPTY_INDEX = Object.freeze({
+    get: () => undefined,
+    getInsensitive: () => undefined,
+    getFilesInDir: () => FROZEN_EMPTY_ARRAY,
+});
+export 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).
+ */
+export 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 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 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/ingestion/import-target-adapter.d.ts

@@ -0,0 +1,73 @@
+/**
+ * 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.
+ */
+import { type SupportedLanguages, type WorkspaceIndex } from '../../_shared/index.js';
+import type { ImportResolverFn, ResolveCtx } from './import-resolvers/types.js';
+import type { LanguageProvider } from './language-provider.js';
+/** A single language's resolver bundled with the context it needs. */
+export interface LanguageResolverEntry {
+    readonly resolver: ImportResolverFn;
+    readonly ctx: ResolveCtx;
+}
+/**
+ * The opaque `workspaceIndex` shape recognized by
+ * `resolveImportTargetAcrossLanguages`. Built once per ingestion run via
+ * `buildImportTargetWorkspace`, threaded through `finalizeScopeModel`.
+ */
+export interface ImportTargetWorkspace {
+    readonly perLanguage: ReadonlyMap<SupportedLanguages, LanguageResolverEntry>;
+}
+/**
+ * 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.
+ */
+export declare function buildImportTargetWorkspace(providers: ReadonlyMap<SupportedLanguages, LanguageProvider>, resolveCtx: ResolveCtx): ImportTargetWorkspace;
+/**
+ * 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.
+ */
+export declare function resolveImportTargetAcrossLanguages(targetRaw: string, fromFile: string, workspaceIndex: WorkspaceIndex): string | null;

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

@@ -0,0 +1,95 @@
+/**
+ * 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.
+ */
+import { getLanguageFromFilename, } from '../../_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.
+ */
+export 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.
+ */
+export function resolveImportTargetAcrossLanguages(targetRaw, fromFile, workspaceIndex) {
+    const workspace = workspaceIndex;
+    if (workspace === undefined || workspace.perLanguage === undefined)
+        return null;
+    const lang = 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/ingestion/language-config.d.ts

@@ -0,0 +1,52 @@
+import type { ImportConfigs } from './import-resolvers/types.js';
+/** TypeScript path alias config parsed from tsconfig.json */
+export interface TsconfigPaths {
+    /** Map of alias prefix -> target prefix (e.g., "@/" -> "src/") */
+    aliases: Map<string, string>;
+    /** Base URL for path resolution (relative to repo root) */
+    baseUrl: string;
+}
+/** Go module config parsed from go.mod */
+export interface GoModuleConfig {
+    /** Module path (e.g., "github.com/user/repo") */
+    modulePath: string;
+}
+/** PHP Composer PSR-4 autoload config */
+export interface ComposerConfig {
+    /** Map of namespace prefix -> directory (e.g., "App\\" -> "app/") */
+    psr4: Map<string, string>;
+    /** PSR-4 entries sorted by namespace length descending (longest match wins).
+     *  Cached once at config load time to avoid re-sorting on every import. */
+    psr4Sorted?: readonly [string, string][];
+}
+/** C# project config parsed from .csproj files */
+export interface CSharpProjectConfig {
+    /** Root namespace from <RootNamespace> or assembly name (default: project directory name) */
+    rootNamespace: string;
+    /** Directory containing the .csproj file */
+    projectDir: string;
+}
+/** Swift Package Manager module config */
+export interface SwiftPackageConfig {
+    /** Map of target name -> source directory path (e.g., "SiuperModel" -> "Package/Sources/SiuperModel") */
+    targets: Map<string, string>;
+}
+/**
+ * Parse tsconfig.json to extract path aliases.
+ * Tries tsconfig.json, tsconfig.app.json, tsconfig.base.json in order.
+ */
+export declare function loadTsconfigPaths(repoRoot: string): Promise<TsconfigPaths | null>;
+/**
+ * Parse go.mod to extract module path.
+ */
+export declare function loadGoModulePath(repoRoot: string): Promise<GoModuleConfig | null>;
+/** Parse composer.json to extract PSR-4 autoload mappings (including autoload-dev). */
+export declare function loadComposerConfig(repoRoot: string): Promise<ComposerConfig | null>;
+/**
+ * Parse .csproj files to extract RootNamespace.
+ * Scans the repo root for .csproj files and returns configs for each.
+ */
+export declare function loadCSharpProjectConfig(repoRoot: string): Promise<CSharpProjectConfig[]>;
+export declare function loadSwiftPackageConfig(repoRoot: string): Promise<SwiftPackageConfig | null>;
+/** Load all language-specific configs once for an ingestion run. */
+export declare function loadImportConfigs(repoRoot: string): Promise<ImportConfigs>;

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

@@ -0,0 +1,181 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { isDev } from './utils/env.js';
+// ============================================================================
+// LANGUAGE-SPECIFIC CONFIG LOADERS
+// ============================================================================
+/**
+ * Parse tsconfig.json to extract path aliases.
+ * Tries tsconfig.json, tsconfig.app.json, tsconfig.base.json in order.
+ */
+export async function loadTsconfigPaths(repoRoot) {
+    const candidates = ['tsconfig.json', 'tsconfig.app.json', 'tsconfig.base.json'];
+    for (const filename of candidates) {
+        try {
+            const tsconfigPath = path.join(repoRoot, filename);
+            const raw = await fs.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 (isDev) {
+                    console.log(`📦 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.
+ */
+export async function loadGoModulePath(repoRoot) {
+    try {
+        const goModPath = path.join(repoRoot, 'go.mod');
+        const content = await fs.readFile(goModPath, 'utf-8');
+        const match = content.match(/^module\s+(\S+)/m);
+        if (match) {
+            if (isDev) {
+                console.log(`📦 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). */
+export async function loadComposerConfig(repoRoot) {
+    try {
+        const composerPath = path.join(repoRoot, 'composer.json');
+        const raw = await fs.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 (isDev) {
+            console.log(`📦 Loaded ${psr4.size} PSR-4 mappings from composer.json`);
+        }
+        return { psr4 };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Parse .csproj files to extract RootNamespace.
+ * Scans the repo root for .csproj files and returns configs for each.
+ */
+export async function loadCSharpProjectConfig(repoRoot) {
+    const configs = [];
+    // BFS scan for .csproj files up to 5 levels deep, cap at 100 dirs to avoid runaway scanning
+    const scanQueue = [{ dir: repoRoot, depth: 0 }];
+    const maxDepth = 5;
+    const maxDirs = 100;
+    let dirsScanned = 0;
+    while (scanQueue.length > 0 && dirsScanned < maxDirs) {
+        const { dir, depth } = scanQueue.shift();
+        dirsScanned++;
+        try {
+            const entries = await fs.readdir(dir, { withFileTypes: true });
+            for (const entry of entries) {
+                if (entry.isDirectory() && depth < maxDepth) {
+                    // Skip common non-project directories
+                    if (entry.name === 'node_modules' ||
+                        entry.name === '.git' ||
+                        entry.name === 'bin' ||
+                        entry.name === 'obj')
+                        continue;
+                    scanQueue.push({ dir: path.join(dir, entry.name), depth: depth + 1 });
+                }
+                if (entry.isFile() && entry.name.endsWith('.csproj')) {
+                    try {
+                        const csprojPath = path.join(dir, entry.name);
+                        const content = await fs.readFile(csprojPath, 'utf-8');
+                        const nsMatch = content.match(/<RootNamespace>\s*([^<]+)\s*<\/RootNamespace>/);
+                        const rootNamespace = nsMatch ? nsMatch[1].trim() : entry.name.replace(/\.csproj$/, '');
+                        const projectDir = path.relative(repoRoot, dir).replace(/\\/g, '/');
+                        configs.push({ rootNamespace, projectDir });
+                        if (isDev) {
+                            console.log(`📦 Loaded C# project: ${entry.name} (namespace: ${rootNamespace}, dir: ${projectDir})`);
+                        }
+                    }
+                    catch {
+                        // Can't read .csproj
+                    }
+                }
+            }
+        }
+        catch {
+            // Can't read directory
+        }
+    }
+    return configs;
+}
+export 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.join(repoRoot, sourceDir);
+            const entries = await fs.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 (isDev) {
+            console.log(`📦 Loaded ${targets.size} Swift package targets`);
+        }
+        return { targets };
+    }
+    return null;
+}
+// ============================================================================
+// BUNDLED CONFIG LOADER
+// ============================================================================
+/** Load all language-specific configs once for an ingestion run. */
+export async function loadImportConfigs(repoRoot) {
+    return {
+        tsconfigPaths: await loadTsconfigPaths(repoRoot),
+        goModule: await loadGoModulePath(repoRoot),
+        composerConfig: await loadComposerConfig(repoRoot),
+        swiftPackageConfig: await loadSwiftPackageConfig(repoRoot),
+        csharpConfigs: await loadCSharpProjectConfig(repoRoot),
+    };
+}