universal-ast-mapper 1.28.0 → 2.0.0

package/dist/complexity.js

@@ -1,98 +0,0 @@
-import fs from "node:fs";
-import { parseSource } from "./parser.js";
-import { detectLanguage } from "./registry.js";
-import { buildSkeleton } from "./skeleton.js";
-import { resolveOptions } from "./config.js";
-// ─── Decision points ───────────────────────────────────────────────────────────
-/**
- * Node types that introduce a branch (each adds 1 to cyclomatic complexity).
- * This is a deliberately broad cross-language union; languages that use a node
- * type not listed here simply undercount rather than miscount.
- */
-const DECISION_TYPES = new Set([
-    // conditionals
-    "if_statement", "if_expression", "elif_clause", "else_if_clause",
-    // loops
-    "for_statement", "for_in_statement", "for_of_statement", "enhanced_for_statement",
-    "for_expression", "while_statement", "while_expression", "do_statement", "loop_statement",
-    // switch / match arms (the default/else arm is intentionally excluded)
-    "switch_case", "expression_case", "type_case", "case_clause", "when_entry",
-    "when_clause", "match_arm", "case_statement",
-    // exception handlers
-    "catch_clause", "except_clause", "rescue_clause",
-    // ternary
-    "ternary_expression", "conditional_expression",
-    // python `and` / `or`
-    "boolean_operator",
-]);
-const FN_KINDS = new Set(["function", "method"]);
-function rate(c) {
-    if (c <= 5)
-        return "low";
-    if (c <= 10)
-        return "moderate";
-    if (c <= 20)
-        return "high";
-    return "very-high";
-}
-/** Collect the start line of every decision point in the tree. */
-function collectDecisionLines(node, out) {
-    const t = node.type;
-    if (DECISION_TYPES.has(t)) {
-        out.push(node.startPosition.row + 1);
-    }
-    else if (t === "binary_expression") {
-        // Short-circuit operators add a branch; arithmetic operators do not.
-        const op = node.childForFieldName("operator");
-        if (op && (op.text === "&&" || op.text === "||"))
-            out.push(node.startPosition.row + 1);
-    }
-    for (let i = 0; i < node.namedChildCount; i++) {
-        const c = node.namedChild(i);
-        if (c)
-            collectDecisionLines(c, out);
-    }
-}
-function flatten(symbols, acc = []) {
-    for (const s of symbols) {
-        acc.push(s);
-        flatten(s.children, acc);
-    }
-    return acc;
-}
-/**
- * Compute cyclomatic complexity for every function/method in a file.
- * Complexity is attributed by line range, so a function's score includes the
- * control flow of any closures/nested functions declared inside it.
- */
-export async function computeFileComplexity(absPath, relPath) {
-    const lang = detectLanguage(absPath);
-    if (!lang)
-        return null;
-    const source = fs.readFileSync(absPath, "utf8");
-    const root = await parseSource(lang.grammar, source);
-    const decisionLines = [];
-    collectDecisionLines(root, decisionLines);
-    const opts = resolveOptions({ detail: "outline", emitHtml: false });
-    const skel = await buildSkeleton(absPath, relPath, opts);
-    const functions = flatten(skel.symbols)
-        .filter((s) => FN_KINDS.has(s.kind))
-        .map((s) => {
-        const count = decisionLines.filter((l) => l >= s.range.startLine && l <= s.range.endLine).length;
-        const complexity = 1 + count;
-        return {
-            name: s.name,
-            kind: s.kind,
-            startLine: s.range.startLine,
-            endLine: s.range.endLine,
-            complexity,
-            rating: rate(complexity),
-        };
-    })
-        .sort((a, b) => b.complexity - a.complexity);
-    const maxComplexity = functions.reduce((m, f) => Math.max(m, f.complexity), 0);
-    const averageComplexity = functions.length === 0
-        ? 0
-        : Math.round((functions.reduce((s, f) => s + f.complexity, 0) / functions.length) * 10) / 10;
-    return { file: skel.file, functions, maxComplexity, averageComplexity };
-}

package/dist/config.js

@@ -1,53 +0,0 @@
-import fs from "node:fs";
-import path from "node:path";
-export const DEFAULT_IGNORE = [
-    "node_modules",
-    "vendor",
-    ".git",
-    "dist",
-    "build",
-    ".next",
-    "out",
-    "__pycache__",
-    ".venv",
-    "venv",
-    ".ast-map",
-];
-let _configCache = null;
-/**
- * Load .ast-map.config.json from the project root.
- * Cached per root path + file mtime so live edits are picked up without restarting.
- * Returns an empty config if no file is found.
- */
-export function loadProjectConfig(root) {
-    const configPath = path.join(root, ".ast-map.config.json");
-    let mtime = 0;
-    try {
-        mtime = fs.statSync(configPath).mtimeMs;
-    }
-    catch { /* file absent */ }
-    if (_configCache?.root === root && _configCache.mtime === mtime)
-        return _configCache.config;
-    let config = {};
-    try {
-        const raw = fs.readFileSync(configPath, "utf8");
-        config = JSON.parse(raw);
-    }
-    catch {
-        // No config file or parse error — use defaults
-    }
-    _configCache = { root, mtime, config };
-    return config;
-}
-export function resolveOptions(opts = {}, projectConfig = {}) {
-    const extraIgnore = projectConfig.ignore ?? [];
-    const mergedIgnore = [...new Set([...DEFAULT_IGNORE, ...extraIgnore])];
-    return {
-        detail: opts.detail ?? "outline",
-        emitHtml: opts.emitHtml ?? true,
-        combineHtml: opts.combineHtml ?? false,
-        outputDir: opts.outputDir ?? projectConfig.outputDir,
-        ignore: opts.ignore ?? mergedIgnore,
-        maxFileBytes: opts.maxFileBytes ?? projectConfig.maxFileBytes ?? 2_000_000,
-    };
-}

package/dist/contextpack.js

@@ -1,79 +0,0 @@
-import fs from "node:fs";
-import path from "node:path";
-import { buildSkeleton, collectSourceFiles } from "./skeleton.js";
-import { resolveOptions } from "./config.js";
-import { resolveFileImports } from "./resolver.js";
-import { buildCallGraph } from "./callgraph.js";
-function findSym(syms, name) {
-    for (const s of syms) {
-        if (s.name === name)
-            return s;
-        const n = findSym(s.children, name);
-        if (n)
-            return n;
-    }
-    return null;
-}
-const tok = (s) => Math.round(s.length / 4);
-/**
- * Assemble the minimal context an agent needs to understand or change a symbol:
- * the symbol's own source, the signatures of what it depends on (resolved
- * imports), and the files that depend on it — instead of reading whole files.
- */
-export async function packContext(absFile, relFile, root, symbolName, scanDir) {
-    const opts = resolveOptions({ detail: "full", emitHtml: false });
-    const skel = await buildSkeleton(absFile, relFile, opts);
-    const lines = fs.readFileSync(absFile, "utf8").split(/\r?\n/);
-    let startLine = 1, endLine = lines.length;
-    if (symbolName) {
-        const sym = findSym(skel.symbols, symbolName);
-        if (sym) {
-            startLine = sym.range.startLine;
-            endLine = sym.range.endLine;
-        }
-    }
-    const source = lines.slice(startLine - 1, endLine).join("\n");
-    // Dependencies: resolved in-project imports + the target symbol signatures.
-    const refs = await resolveFileImports(skel, absFile, root);
-    const byFile = new Map();
-    for (const r of refs) {
-        if (!r.found || !r.resolvedRel)
-            continue;
-        const arr = byFile.get(r.resolvedRel) ?? [];
-        if (!arr.some((x) => x.name === r.symbol))
-            arr.push({ name: r.symbol, signature: r.signature ?? null });
-        byFile.set(r.resolvedRel, arr);
-    }
-    const dependencies = [...byFile.entries()].map(([file, symbols]) => ({ file, symbols }));
-    // Dependents: who calls the seed symbol (needs a directory scan).
-    let dependents = [];
-    if (symbolName && scanDir) {
-        const sopts = resolveOptions({ detail: "outline", emitHtml: false });
-        const skels = [];
-        for (const f of collectSourceFiles(scanDir, sopts)) {
-            const rr = path.relative(root, f).split(path.sep).join("/");
-            try {
-                skels.push(await buildSkeleton(f, rr, sopts));
-            }
-            catch { /* skip */ }
-        }
-        const cg = await buildCallGraph(absFile, symbolName, root, skels);
-        if (cg) {
-            const seen = new Set();
-            for (const c of cg.calledBy)
-                if (!seen.has(c.file)) {
-                    seen.add(c.file);
-                    dependents.push({ file: c.file });
-                }
-        }
-    }
-    const depTok = dependencies.reduce((a, d) => a + d.symbols.reduce((b, s) => b + tok(s.signature || s.name), 0), 0);
-    return {
-        seed: { file: relFile, ...(symbolName ? { symbol: symbolName } : {}) },
-        primary: { file: relFile, ...(symbolName ? { symbol: symbolName } : {}), startLine, endLine, source },
-        dependencies,
-        dependents,
-        tokenEstimate: tok(source) + depTok,
-        note: "Read primary.source in full; for dependencies you usually only need the listed signatures, not the whole files.",
-    };
-}

package/dist/coupling.js

@@ -1,35 +0,0 @@
-/**
- * Compute Robert C. Martin's coupling metrics per file from the symbol graph's
- * file-level import edges: afferent (fan-in), efferent (fan-out), and instability.
- */
-export function computeCoupling(graph) {
-    const nodeMap = new Map(graph.nodes.map((n) => [n.id, n]));
-    const out = new Map(); // file -> set of files it imports
-    const inc = new Map(); // file -> set of files that import it
-    const files = new Set();
-    for (const n of graph.nodes)
-        if (n.nodeType === "file")
-            files.add(n.id);
-    for (const e of graph.edges) {
-        if (e.edgeType !== "imports")
-            continue;
-        const to = nodeMap.get(e.to);
-        const toFile = to ? (to.nodeType === "file" ? to.id : to.file) : null;
-        const fromFile = e.from;
-        if (!toFile || fromFile === toFile)
-            continue;
-        files.add(fromFile);
-        files.add(toFile);
-        (out.get(fromFile) ?? out.set(fromFile, new Set()).get(fromFile)).add(toFile);
-        (inc.get(toFile) ?? inc.set(toFile, new Set()).get(toFile)).add(fromFile);
-    }
-    const metrics = [];
-    for (const f of files) {
-        const ce = out.get(f)?.size ?? 0;
-        const ca = inc.get(f)?.size ?? 0;
-        const instability = ca + ce === 0 ? 0 : Math.round((ce / (ca + ce)) * 100) / 100;
-        metrics.push({ file: f, afferent: ca, efferent: ce, instability });
-    }
-    // Sort by total coupling desc (most-connected first).
-    return metrics.sort((a, b) => (b.afferent + b.efferent) - (a.afferent + a.efferent) || a.file.localeCompare(b.file));
-}

package/dist/crosslang.js

@@ -1,425 +0,0 @@
-import fs from "node:fs";
-import path from "node:path";
-const TYPE_KINDS = new Set(["class", "interface", "enum", "struct"]);
-/** Walk a symbol tree and yield each top-level type-like symbol. */
-function topTypeSymbols(symbols) {
-    return symbols.filter((s) => TYPE_KINDS.has(s.kind));
-}
-function getDirectiveValue(skel, prefix) {
-    const hit = (skel.directives ?? []).find((d) => d.startsWith(prefix));
-    return hit ? hit.slice(prefix.length) : null;
-}
-function getAllDirectiveValues(skel, prefix) {
-    return (skel.directives ?? [])
-        .filter((d) => d.startsWith(prefix))
-        .map((d) => d.slice(prefix.length));
-}
-/**
- * Build Java + C# indexes from already-parsed skeletons.
- * Cheap: O(symbols), no extra file reads.
- */
-export function buildCrossLangIndex(skeletons) {
-    const index = {
-        javaFqcn: new Map(),
-        javaPackages: new Map(),
-        csharpNamespaces: new Map(),
-        csharpTypes: new Map(),
-        kotlinFqcn: new Map(),
-        kotlinPackages: new Map(),
-        swiftModules: new Map(),
-    };
-    for (const skel of skeletons) {
-        if (skel.language === "java") {
-            const pkg = getDirectiveValue(skel, "package:");
-            if (!pkg)
-                continue;
-            const pkgFiles = index.javaPackages.get(pkg) ?? [];
-            pkgFiles.push(skel.file);
-            index.javaPackages.set(pkg, pkgFiles);
-            for (const sym of topTypeSymbols(skel.symbols)) {
-                index.javaFqcn.set(`${pkg}.${sym.name}`, skel.file);
-            }
-        }
-        else if (skel.language === "csharp") {
-            const namespaces = getAllDirectiveValues(skel, "namespace:");
-            for (const ns of namespaces) {
-                const arr = index.csharpNamespaces.get(ns) ?? [];
-                if (!arr.includes(skel.file))
-                    arr.push(skel.file);
-                index.csharpNamespaces.set(ns, arr);
-            }
-            // Map every top-level type to <ns>.<TypeName>. For files with multiple
-            // namespaces this is approximate (we don't know per-symbol scoping
-            // without per-symbol namespace tracking) but accurate for the common case
-            // of one namespace per file.
-            for (const sym of topTypeSymbols(skel.symbols)) {
-                for (const ns of namespaces) {
-                    index.csharpTypes.set(`${ns}.${sym.name}`, skel.file);
-                }
-            }
-        }
-        else if (skel.language === "kotlin") {
-            const pkg = getDirectiveValue(skel, "package:");
-            if (!pkg)
-                continue;
-            const pkgFiles = index.kotlinPackages.get(pkg) ?? [];
-            pkgFiles.push(skel.file);
-            index.kotlinPackages.set(pkg, pkgFiles);
-            for (const sym of topTypeSymbols(skel.symbols)) {
-                index.kotlinFqcn.set(`${pkg}.${sym.name}`, skel.file);
-            }
-        }
-        else if (skel.language === "swift") {
-            const mod = swiftModuleOf(skel.file);
-            if (!mod)
-                continue;
-            const arr = index.swiftModules.get(mod) ?? [];
-            arr.push(skel.file);
-            index.swiftModules.set(mod, arr);
-        }
-    }
-    return index;
-}
-/**
- * Derive a Swift module name from a project-relative file path.
- * SwiftPM convention: sources live under `Sources/<ModuleName>/...`, so the
- * module is the path segment right after `Sources`. For flat layouts we fall
- * back to the immediate parent directory name. Returns null for bare files.
- */
-function swiftModuleOf(relFile) {
-    const parts = relFile.split("/");
-    const srcIdx = parts.lastIndexOf("Sources");
-    if (srcIdx >= 0 && srcIdx + 1 < parts.length - 1)
-        return parts[srcIdx + 1];
-    if (parts.length >= 2)
-        return parts[parts.length - 2];
-    return null;
-}
-/* ─── Rust module resolution ──────────────────────────────────────────────── */
-function findCargoRoot(fromAbs, projectRoot) {
-    let dir = path.dirname(fromAbs);
-    const stop = path.resolve(projectRoot);
-    while (true) {
-        if (fs.existsSync(path.join(dir, "Cargo.toml")))
-            return dir;
-        if (dir === stop || dir === path.dirname(dir))
-            return null;
-        dir = path.dirname(dir);
-    }
-}
-function existsFile(p) {
-    try {
-        return fs.statSync(p).isFile();
-    }
-    catch {
-        return false;
-    }
-}
-function existsDir(p) {
-    try {
-        return fs.statSync(p).isDirectory();
-    }
-    catch {
-        return false;
-    }
-}
-/** Walk module path segments down from a base dir, returning the resolved .rs file. */
-function walkRustModule(base, segs) {
-    if (segs.length === 0) {
-        // base IS the target module dir/file. Try canonical roots.
-        for (const candidate of ["mod.rs", "lib.rs", "main.rs"]) {
-            const p = path.join(base, candidate);
-            if (existsFile(p))
-                return p;
-        }
-        if (existsFile(base + ".rs"))
-            return base + ".rs";
-        return null;
-    }
-    const [head, ...rest] = segs;
-    if (rest.length === 0) {
-        // Terminal segment: `head.rs` or `head/mod.rs`.
-        const p1 = path.join(base, `${head}.rs`);
-        if (existsFile(p1))
-            return p1;
-        const p2 = path.join(base, head, "mod.rs");
-        if (existsFile(p2))
-            return p2;
-        return null;
-    }
-    // Non-terminal: descend into a directory module.
-    const subDir = path.join(base, head);
-    if (existsDir(subDir))
-        return walkRustModule(subDir, rest);
-    // Rust-2018 style: `head.rs` next to a sibling `head/` directory.
-    if (existsFile(path.join(base, `${head}.rs`)) && existsDir(path.join(base, head))) {
-        return walkRustModule(path.join(base, head), rest);
-    }
-    return null;
-}
-/**
- * Resolve a Rust `use` path to an absolute .rs file.
- * Handles `crate::`, `self::`, `super::` prefixes; anything else is treated
- * as an external crate (e.g. `std::`, `tokio::`) and returns null.
- *
- * @param importFrom Full use path, e.g. "crate::foo::Bar"
- * @param fromAbs   Absolute path of the importing file
- * @param projectRoot Absolute project root (security boundary)
- */
-export function resolveRustModule(importFrom, fromAbs, projectRoot) {
-    const segs = importFrom.split("::");
-    if (segs.length === 0)
-        return null;
-    // Strip the imported item name (last segment) — leaves the module path.
-    const moduleSegs = segs.slice(0, -1);
-    if (moduleSegs.length === 0)
-        return null;
-    const head = moduleSegs[0];
-    let base;
-    let remaining;
-    if (head === "crate") {
-        const cargoRoot = findCargoRoot(fromAbs, projectRoot);
-        if (!cargoRoot)
-            return null;
-        base = path.join(cargoRoot, "src");
-        if (!existsDir(base))
-            base = cargoRoot;
-        remaining = moduleSegs.slice(1);
-    }
-    else if (head === "self") {
-        base = path.dirname(fromAbs);
-        remaining = moduleSegs.slice(1);
-    }
-    else if (head === "super") {
-        let dir = path.dirname(fromAbs);
-        let i = 0;
-        while (moduleSegs[i] === "super") {
-            dir = path.dirname(dir);
-            i++;
-        }
-        base = dir;
-        remaining = moduleSegs.slice(i);
-    }
-    else {
-        return null; // external crate
-    }
-    return walkRustModule(base, remaining);
-}
-// Cache per project root.
-const goModuleCache = new Map();
-function readGoModulePath(modFile) {
-    try {
-        const txt = fs.readFileSync(modFile, "utf8");
-        const m = /^\s*module\s+(\S+)/m.exec(txt);
-        return m ? m[1] : null;
-    }
-    catch {
-        return null;
-    }
-}
-/** Locate the go.mod ancestor (within projectRoot) of `fromAbs`. */
-function findGoModule(fromAbs, projectRoot) {
-    const key = path.resolve(projectRoot);
-    if (goModuleCache.has(key)) {
-        // Cached at the project root level — assumes one go.mod per project root.
-        // For monorepos with multiple modules, ResolveGoImport falls back to a
-        // walk-up search below.
-        const cached = goModuleCache.get(key);
-        if (cached)
-            return cached;
-    }
-    let dir = path.dirname(fromAbs);
-    const stop = key;
-    while (true) {
-        const modFile = path.join(dir, "go.mod");
-        if (existsFile(modFile)) {
-            const modPath = readGoModulePath(modFile);
-            if (modPath) {
-                const result = { modulePath: modPath, moduleDir: dir };
-                if (dir === stop)
-                    goModuleCache.set(key, result);
-                return result;
-            }
-        }
-        if (dir === stop || dir === path.dirname(dir))
-            return null;
-        dir = path.dirname(dir);
-    }
-}
-/**
- * Resolve a Go import path to a list of .go files in the resolved package
- * directory. Returns null for stdlib / third-party / unresolvable paths.
- *
- * Go semantics:
- *   - A package is a directory containing one or more .go files.
- *   - `import "github.com/x/y/z"` maps to <moduleDir>/<subpath> when the prefix
- *     matches the current module's path.
- */
-export function resolveGoImport(importFrom, fromAbs, projectRoot) {
-    const mod = findGoModule(fromAbs, projectRoot);
-    if (!mod)
-        return null;
-    let subPath;
-    if (importFrom === mod.modulePath) {
-        subPath = "";
-    }
-    else if (importFrom.startsWith(mod.modulePath + "/")) {
-        subPath = importFrom.slice(mod.modulePath.length + 1);
-    }
-    else {
-        return null; // external / stdlib
-    }
-    const pkgDir = subPath ? path.join(mod.moduleDir, subPath) : mod.moduleDir;
-    if (!existsDir(pkgDir))
-        return null;
-    // Collect every .go file in the directory (Go packages span all files in dir).
-    // Skip _test.go files — call graph cares about production code.
-    let entries;
-    try {
-        entries = fs.readdirSync(pkgDir, { withFileTypes: true });
-    }
-    catch {
-        return null;
-    }
-    const files = [];
-    for (const e of entries) {
-        if (!e.isFile())
-            continue;
-        if (!e.name.endsWith(".go"))
-            continue;
-        if (e.name.endsWith("_test.go"))
-            continue;
-        const abs = path.join(pkgDir, e.name);
-        const rel = path.relative(projectRoot, abs).split(path.sep).join("/");
-        files.push(rel);
-    }
-    return files.length > 0 ? files : null;
-}
-/** Test/debug hook: drop the cached Go module info. */
-export function clearGoModuleCache() {
-    goModuleCache.clear();
-}
-/* ─── C / C++ #include resolution ─────────────────────────────────────────── */
-const HEADER_EXTS = [".h", ".hpp", ".hxx", ".hh"];
-const IMPL_EXTS = [".c", ".cpp", ".cc", ".cxx"];
-/**
- * Resolve a C/C++ `#include "foo.h"` to in-project files.
- * Convention: also pair foo.h with foo.c/.cpp in the same directory so the
- * graph captures the header → impl relationship.
- * `#include <foo.h>` (system headers) returns null (external).
- */
-export function resolveCInclude(importFrom, fromAbs, projectRoot) {
-    // System headers like stdio.h, vector, etc. — leave to external.
-    const isSystemHeader = !importFrom.includes("/") && !importFrom.includes(".") ||
-        /^(stdio|stdlib|string|vector|memory|cstdint|cstdlib|cstring|iostream)/.test(importFrom);
-    // We only check the actual filesystem; if a system header happens to exist
-    // locally we still link it, otherwise it falls through to null.
-    const fromDir = path.dirname(fromAbs);
-    const headerAbs = path.resolve(fromDir, importFrom);
-    const out = [];
-    if (existsFile(headerAbs)) {
-        const rel = path.relative(projectRoot, headerAbs).split(path.sep).join("/");
-        // Reject paths that escape the project root.
-        if (!rel.startsWith(".."))
-            out.push(rel);
-        // Pair foo.h with foo.{c,cpp,cc,cxx} in the same directory.
-        const ext = path.extname(headerAbs).toLowerCase();
-        if (HEADER_EXTS.includes(ext)) {
-            const base = headerAbs.slice(0, -ext.length);
-            for (const implExt of IMPL_EXTS) {
-                const implAbs = base + implExt;
-                if (existsFile(implAbs)) {
-                    const implRel = path.relative(projectRoot, implAbs).split(path.sep).join("/");
-                    if (!implRel.startsWith(".."))
-                        out.push(implRel);
-                }
-            }
-        }
-    }
-    if (isSystemHeader && out.length === 0)
-        return null;
-    return out.length > 0 ? out : null;
-}
-/**
- * Resolve an ImportRef in a non-relative-path language to a graph target.
- * Returns null for unresolvable / external imports.
- */
-export function resolveCrossLangTarget(imp, skel, fromAbs, projectRoot, index) {
-    if (skel.language === "java") {
-        if (imp.symbol === "*") {
-            // wildcard: pull all files in the package
-            const files = index.javaPackages.get(imp.from);
-            if (files && files.length > 0)
-                return { kind: "file", files: files.slice() };
-            return null;
-        }
-        const targetFile = index.javaFqcn.get(imp.from);
-        if (targetFile)
-            return { kind: "symbol", file: targetFile, symbol: imp.symbol };
-        return null;
-    }
-    if (skel.language === "csharp") {
-        const files = index.csharpNamespaces.get(imp.from);
-        if (files && files.length > 0) {
-            // Exclude self — a file `using App;` while declaring in App shouldn't self-edge.
-            const filtered = files.filter((f) => f !== skel.file);
-            if (filtered.length > 0)
-                return { kind: "file", files: filtered };
-        }
-        return null;
-    }
-    if (skel.language === "rust") {
-        const abs = resolveRustModule(imp.from, fromAbs, projectRoot);
-        if (!abs)
-            return null;
-        const rel = path.relative(projectRoot, abs).split(path.sep).join("/");
-        return { kind: "symbol", file: rel, symbol: imp.symbol };
-    }
-    if (skel.language === "go") {
-        const files = resolveGoImport(imp.from, fromAbs, projectRoot);
-        if (!files || files.length === 0)
-            return null;
-        const filtered = files.filter((f) => f !== skel.file);
-        if (filtered.length === 0)
-            return null;
-        return { kind: "file", files: filtered };
-    }
-    if (skel.language === "kotlin") {
-        if (imp.symbol === "*") {
-            const files = index.kotlinPackages.get(imp.from);
-            if (files && files.length > 0) {
-                const filtered = files.filter((f) => f !== skel.file);
-                if (filtered.length > 0)
-                    return { kind: "file", files: filtered };
-            }
-            return null;
-        }
-        const targetFile = index.kotlinFqcn.get(imp.from);
-        if (targetFile && targetFile !== skel.file) {
-            return { kind: "symbol", file: targetFile, symbol: imp.symbol };
-        }
-        return null;
-    }
-    if (skel.language === "c" || skel.language === "cpp") {
-        const files = resolveCInclude(imp.from, fromAbs, projectRoot);
-        if (!files || files.length === 0)
-            return null;
-        const filtered = files.filter((f) => f !== skel.file);
-        if (filtered.length === 0)
-            return null;
-        return { kind: "file", files: filtered };
-    }
-    if (skel.language === "swift") {
-        // `import <Module>` brings in another in-project module's public symbols
-        // (no symbol named). Resolve to that module's files; unknown modules
-        // (Foundation, UIKit, …) are external.
-        const files = index.swiftModules.get(imp.from);
-        if (files && files.length > 0) {
-            const filtered = files.filter((f) => f !== skel.file);
-            if (filtered.length > 0)
-                return { kind: "file", files: filtered };
-        }
-        return null;
-    }
-    return null;
-}