universal-ast-mapper 0.5.3 → 0.7.0

package/dist/extractors/rust.js

@@ -0,0 +1,249 @@
+import { namedChildren, nameOf, headerSignature, leadingComment } from "../parser.js";
+import { makeSymbol } from "./common.js";
+/* ─── helpers ─────────────────────────────────────────────────────────────── */
+function childOfType(node, type) {
+    for (let i = 0; i < node.childCount; i++) {
+        const c = node.child(i);
+        if (c && c.type === type)
+            return c;
+    }
+    return null;
+}
+/** Rust: `pub`, `pub(crate)`, ... = public; anything else = module-private. */
+function isPub(node) {
+    const vis = childOfType(node, "visibility_modifier");
+    return !!vis && vis.text.startsWith("pub");
+}
+function vis(node) {
+    return isPub(node) ? "public" : "private";
+}
+/* ─── import extraction ───────────────────────────────────────────────────── */
+export function extractImportsRust(root, _source) {
+    const out = [];
+    for (const child of namedChildren(root)) {
+        if (child.type === "use_declaration") {
+            const arg = child.namedChild(0);
+            if (arg)
+                resolveUse(arg, "", out);
+        }
+    }
+    return out;
+}
+function resolveUse(node, prefix, out) {
+    switch (node.type) {
+        case "identifier":
+        case "type_identifier":
+            out.push({ symbol: node.text, from: join(prefix, node.text) });
+            return;
+        case "scoped_identifier": {
+            const full = node.text;
+            const sym = full.split("::").pop() ?? full;
+            out.push({ symbol: sym, from: full });
+            return;
+        }
+        case "use_as_clause": {
+            const path = node.namedChild(0);
+            const alias = node.namedChild(1);
+            const full = path ? path.text : "";
+            const sym = full.split("::").pop() ?? full;
+            out.push({ symbol: sym, from: full, alias: alias?.text });
+            return;
+        }
+        case "use_wildcard": {
+            const path = node.namedChild(0);
+            out.push({ symbol: "*", from: path ? path.text : prefix, isNamespaceImport: true });
+            return;
+        }
+        case "scoped_use_list": {
+            const base = node.namedChild(0);
+            const list = childOfType(node, "use_list");
+            const newPrefix = base ? base.text : prefix;
+            if (list) {
+                for (const item of namedChildren(list))
+                    resolveUse(item, newPrefix, out);
+            }
+            return;
+        }
+        case "use_list":
+            for (const item of namedChildren(node))
+                resolveUse(item, prefix, out);
+            return;
+        default:
+            return;
+    }
+}
+function join(prefix, name) {
+    return prefix ? `${prefix}::${name}` : name;
+}
+/* ─── symbol extraction ───────────────────────────────────────────────────── */
+export function extractRust(root, _source) {
+    return collect(namedChildren(root));
+}
+function collect(nodes) {
+    const out = [];
+    for (const n of nodes) {
+        const res = handle(n);
+        if (Array.isArray(res))
+            out.push(...res);
+        else if (res)
+            out.push(res);
+    }
+    return out;
+}
+function handle(node) {
+    switch (node.type) {
+        case "struct_item": {
+            const name = nameOf(node) ?? "(struct)";
+            const body = node.childForFieldName("body");
+            return makeSymbol({
+                name,
+                kind: "struct",
+                node,
+                rawKind: node.type,
+                visibility: vis(node),
+                exported: isPub(node),
+                doc: leadingComment(node),
+                children: body && body.type === "field_declaration_list" ? structFields(body) : [],
+            });
+        }
+        case "trait_item": {
+            const name = nameOf(node) ?? "(trait)";
+            const body = node.childForFieldName("body");
+            return makeSymbol({
+                name,
+                kind: "interface",
+                node,
+                rawKind: node.type,
+                visibility: vis(node),
+                exported: isPub(node),
+                doc: leadingComment(node),
+                children: body ? traitMethods(body) : [],
+            });
+        }
+        case "enum_item":
+            return makeSymbol({
+                name: nameOf(node) ?? "(enum)",
+                kind: "enum",
+                node,
+                rawKind: node.type,
+                visibility: vis(node),
+                exported: isPub(node),
+                doc: leadingComment(node),
+            });
+        case "function_item": {
+            const name = nameOf(node) ?? "(fn)";
+            return makeSymbol({
+                name,
+                kind: "function",
+                node,
+                rawKind: node.type,
+                signature: headerSignature(node, node.childForFieldName("body")),
+                visibility: vis(node),
+                exported: isPub(node),
+                doc: leadingComment(node),
+            });
+        }
+        case "impl_item": {
+            // Surface impl methods as `Type::method` so the association is visible.
+            const typeNode = node.childForFieldName("type");
+            const typeName = typeNode ? typeNode.text : "";
+            const body = node.childForFieldName("body");
+            const out = [];
+            if (body) {
+                for (const m of namedChildren(body)) {
+                    if (m.type !== "function_item")
+                        continue;
+                    const mName = nameOf(m) ?? "(fn)";
+                    out.push(makeSymbol({
+                        name: typeName ? `${typeName}::${mName}` : mName,
+                        kind: "method",
+                        node: m,
+                        rawKind: m.type,
+                        signature: headerSignature(m, m.childForFieldName("body")),
+                        visibility: vis(m),
+                        exported: isPub(m),
+                        doc: leadingComment(m),
+                    }));
+                }
+            }
+            return out;
+        }
+        case "const_item":
+            return makeSymbol({
+                name: nameOf(node) ?? "(const)",
+                kind: "const",
+                node,
+                rawKind: node.type,
+                signature: headerSignature(node, node.childForFieldName("value")),
+                visibility: vis(node),
+                exported: isPub(node),
+            });
+        case "static_item":
+            return makeSymbol({
+                name: nameOf(node) ?? "(static)",
+                kind: "var",
+                node,
+                rawKind: node.type,
+                signature: headerSignature(node, node.childForFieldName("value")),
+                visibility: vis(node),
+                exported: isPub(node),
+            });
+        case "type_item":
+            return makeSymbol({
+                name: nameOf(node) ?? "(type)",
+                kind: "type",
+                node,
+                rawKind: node.type,
+                signature: headerSignature(node, null),
+                visibility: vis(node),
+                exported: isPub(node),
+            });
+        case "mod_item": {
+            // Flatten module contents to the top level.
+            const body = node.childForFieldName("body");
+            return body ? collect(namedChildren(body)) : null;
+        }
+        default:
+            return null;
+    }
+}
+function structFields(list) {
+    const out = [];
+    for (const field of namedChildren(list)) {
+        if (field.type !== "field_declaration")
+            continue;
+        const name = nameOf(field);
+        if (!name)
+            continue;
+        out.push(makeSymbol({
+            name,
+            kind: "field",
+            node: field,
+            rawKind: field.type,
+            signature: field.text.replace(/\s+/g, " ").trim(),
+            visibility: vis(field),
+            exported: isPub(field),
+        }));
+    }
+    return out;
+}
+function traitMethods(body) {
+    const out = [];
+    for (const m of namedChildren(body)) {
+        if (m.type !== "function_signature_item" && m.type !== "function_item")
+            continue;
+        const name = nameOf(m);
+        if (!name)
+            continue;
+        out.push(makeSymbol({
+            name,
+            kind: "method",
+            node: m,
+            rawKind: m.type,
+            signature: headerSignature(m, m.childForFieldName("body")),
+            visibility: "public",
+            exported: true,
+        }));
+    }
+    return out;
+}

package/dist/graph.js

@@ -1,9 +1,9 @@
 import path from "node:path";
 import { resolveImportPath } from "./resolver.js";
+import { buildCrossLangIndex, resolveCrossLangTarget, } from "./crosslang.js";
 // ─── Internal helpers ─────────────────────────────────────────────────────────
 function collectSymbolNodes(symbols, parentId, file, nodes, edges) {
     for (const sym of symbols) {
-        // Nested symbols use dot-notation: "src/foo.ts::MyClass.methodName"
         const nodeId = `${parentId}.${sym.name}`;
         nodes.push({
             id: nodeId,
@@ -21,28 +21,70 @@ function collectSymbolNodes(symbols, parentId, file, nodes, edges) {
         }
     }
 }
+// Returns true for path-based import languages (TS/JS/Python/Go).
+function isPathBasedLanguage(language) {
+    return (language === "typescript" ||
+        language === "tsx" ||
+        language === "javascript" ||
+        language === "python");
+}
+// Wire one TS/JS/Python-style relative import.
+function wirePathImport(skel, imp, fromFileAbs, root, exportedSymbolMap, edges) {
+    if (!imp.from.startsWith("."))
+        return;
+    if (imp.isSideEffect)
+        return;
+    const resolvedAbs = resolveImportPath(imp.from, fromFileAbs);
+    if (!resolvedAbs)
+        return;
+    const resolvedRel = path.relative(root, resolvedAbs).split(path.sep).join("/");
+    if (imp.isNamespaceImport || imp.symbol === "*") {
+        if (exportedSymbolMap.has(resolvedRel)) {
+            edges.push({ from: skel.file, to: resolvedRel, edgeType: "imports" });
+        }
+    }
+    else {
+        const fileExports = exportedSymbolMap.get(resolvedRel);
+        const targetNodeId = fileExports?.get(imp.symbol);
+        if (targetNodeId) {
+            edges.push({ from: skel.file, to: targetNodeId, edgeType: "imports" });
+        }
+    }
+}
+// Wire one cross-language import (Java/C#/Rust) using the project-wide index.
+function wireCrossLangImport(skel, imp, fromFileAbs, root, index, exportedSymbolMap, edges) {
+    if (imp.isSideEffect)
+        return;
+    const target = resolveCrossLangTarget(imp, skel, fromFileAbs, root, index);
+    if (!target)
+        return;
+    if (target.kind === "file") {
+        for (const f of target.files) {
+            if (exportedSymbolMap.has(f) && f !== skel.file) {
+                edges.push({ from: skel.file, to: f, edgeType: "imports" });
+            }
+        }
+        return;
+    }
+    // target.kind === "symbol"
+    const fileExports = exportedSymbolMap.get(target.file);
+    const targetNodeId = fileExports?.get(target.symbol);
+    if (targetNodeId) {
+        edges.push({ from: skel.file, to: targetNodeId, edgeType: "imports" });
+    }
+    else if (exportedSymbolMap.has(target.file) && target.file !== skel.file) {
+        // Symbol not found in the resolved file — fall back to a file-level edge so
+        // the graph still reflects the cross-file dependency.
+        edges.push({ from: skel.file, to: target.file, edgeType: "imports" });
+    }
+}
 // ─── Public builder ──────────────────────────────────────────────────────────
-/**
- * Build a symbol-level dependency graph from an array of pre-parsed skeletons.
- *
- * Node IDs:
- *   - File node:   "<relPath>"                       e.g. "src/utils.ts"
- *   - Top symbol:  "<relPath>::<Name>"               e.g. "src/utils.ts::sanitize"
- *   - Nested:      "<relPath>::<Parent>.<Child>"     e.g. "src/utils.ts::MyClass.render"
- *
- * Edge types:
- *   - "contains"  file → symbol (and parent-symbol → child-symbol)
- *   - "imports"   importing-file → imported-symbol-node
- */
 export function buildSymbolGraph(skeletons, root) {
     const nodes = [];
     const edges = [];
-    // exportedSymbolMap: relFile → (symbolName → nodeId)
-    // Used in the second pass to resolve import targets.
     const exportedSymbolMap = new Map();
-    // ── First pass: build all file + symbol nodes ────────────────────────────
+    // First pass: build file and symbol nodes.
     for (const skel of skeletons) {
-        // File node
         nodes.push({
             id: skel.file,
             nodeType: "file",
@@ -64,9 +106,15 @@ export function buildSymbolGraph(skeletons, root) {
                 ...(sym.signature ? { signature: sym.signature } : {}),
             });
             edges.push({ from: skel.file, to: nodeId, edgeType: "contains" });
+            // Index exported (and visible-by-convention) top-level symbols so that
+            // imports can find them. Languages like Java/C# may have visible types
+            // without an explicit "exported" flag — fall back to indexing all
+            // top-level symbols for those languages.
             if (sym.exported)
                 fileExports.set(sym.name, nodeId);
-            // Collect nested symbols
+            else if (skel.language === "java" || skel.language === "csharp") {
+                fileExports.set(sym.name, nodeId);
+            }
             if (sym.children.length > 0) {
                 const childNodes = [];
                 const childEdges = [];
@@ -76,32 +124,23 @@ export function buildSymbolGraph(skeletons, root) {
             }
         }
     }
-    // ── Second pass: wire import edges ───────────────────────────────────────
+    // Build cross-language indexes once (Java FQCN, C# namespaces).
+    const crossIndex = buildCrossLangIndex(skeletons);
+    // Second pass: wire import edges, dispatched by language.
     for (const skel of skeletons) {
         if (!skel.imports || skel.imports.length === 0)
             continue;
         const fromFileAbs = path.resolve(root, skel.file);
+        const pathBased = isPathBasedLanguage(skel.language);
         for (const imp of skel.imports) {
-            if (!imp.from.startsWith("."))
-                continue; // skip external packages
-            if (imp.isSideEffect)
-                continue;
-            const resolvedAbs = resolveImportPath(imp.from, fromFileAbs);
-            if (!resolvedAbs)
-                continue;
-            const resolvedRel = path.relative(root, resolvedAbs).split(path.sep).join("/");
-            if (imp.isNamespaceImport || imp.symbol === "*") {
-                // Namespace import — link to the file node itself
-                if (exportedSymbolMap.has(resolvedRel)) {
-                    edges.push({ from: skel.file, to: resolvedRel, edgeType: "imports" });
-                }
+            if (pathBased) {
+                wirePathImport(skel, imp, fromFileAbs, root, exportedSymbolMap, edges);
             }
-            else {
-                const fileExports = exportedSymbolMap.get(resolvedRel);
-                const targetNodeId = fileExports?.get(imp.symbol);
-                if (targetNodeId) {
-                    edges.push({ from: skel.file, to: targetNodeId, edgeType: "imports" });
-                }
+            else if (skel.language === "java" ||
+                skel.language === "csharp" ||
+                skel.language === "rust" ||
+                skel.language === "go") {
+                wireCrossLangImport(skel, imp, fromFileAbs, root, crossIndex, exportedSymbolMap, edges);
             }
         }
     }

package/dist/registry.js

@@ -2,6 +2,9 @@ import path from "node:path";
 import { extractTypeScript, extractDirectivesTS, extractImportsTS } from "./extractors/typescript.js";
 import { extractPython, extractImportsPython } from "./extractors/python.js";
 import { extractGo, extractImportsGo } from "./extractors/go.js";
+import { extractRust, extractImportsRust } from "./extractors/rust.js";
+import { extractJava, extractDirectivesJava, extractImportsJava } from "./extractors/java.js";
+import { extractCSharp, extractDirectivesCSharp, extractImportsCSharp } from "./extractors/csharp.js";
 const TS_ENTRY = (language, grammar) => ({
     language,
     grammar,
@@ -9,7 +12,6 @@ const TS_ENTRY = (language, grammar) => ({
     extractDirectives: extractDirectivesTS,
     extractImports: extractImportsTS,
 });
-/** Map of file extension -> language entry. The Factory/Strategy registry. */
 const BY_EXT = {
     ".ts": TS_ENTRY("typescript", "typescript"),
     ".mts": TS_ENTRY("typescript", "typescript"),
@@ -22,6 +24,21 @@ const BY_EXT = {
     ".py": { language: "python", grammar: "python", extract: extractPython, extractImports: extractImportsPython },
     ".pyi": { language: "python", grammar: "python", extract: extractPython, extractImports: extractImportsPython },
     ".go": { language: "go", grammar: "go", extract: extractGo, extractImports: extractImportsGo },
+    ".rs": { language: "rust", grammar: "rust", extract: extractRust, extractImports: extractImportsRust },
+    ".java": {
+        language: "java",
+        grammar: "java",
+        extract: extractJava,
+        extractDirectives: extractDirectivesJava,
+        extractImports: extractImportsJava,
+    },
+    ".cs": {
+        language: "csharp",
+        grammar: "c_sharp",
+        extract: extractCSharp,
+        extractDirectives: extractDirectivesCSharp,
+        extractImports: extractImportsCSharp,
+    },
 };
 export function detectLanguage(filePath) {
     return BY_EXT[path.extname(filePath).toLowerCase()] ?? null;

package/dist/resolver.js

@@ -1,10 +1,10 @@
 import fs from "node:fs";
 import path from "node:path";
-import { buildSkeleton } from "./skeleton.js";
+import { buildSkeleton, collectSourceFiles } from "./skeleton.js";
 import { resolveOptions } from "./config.js";
 import { findSymbol } from "./analysis.js";
+import { buildCrossLangIndex, resolveCrossLangTarget, } from "./crosslang.js";
 const SRC_EXTS = [".ts", ".tsx", ".js", ".jsx", ".mts", ".cts", ".mjs", ".cjs"];
-/** Extract the outermost balanced parenthesised group from a signature string. */
 function extractParams(sig) {
     const start = sig.indexOf("(");
     if (start === -1)
@@ -21,8 +21,6 @@ function extractParams(sig) {
     }
     return null;
 }
-// TypeScript ESM: `import from "./foo.js"` actually means `./foo.ts` on disk.
-// Map each JS-family extension to the TS-family equivalents we should try first.
 const JS_TO_TS = {
     ".js": [".ts", ".tsx", ".js"],
     ".jsx": [".tsx", ".jsx"],
@@ -30,8 +28,7 @@ const JS_TO_TS = {
     ".cjs": [".cts", ".cjs"],
 };
 /**
- * Resolve a relative import path from a source file to an absolute path on disk.
- * Handles TypeScript ESM convention (`.js` in source → `.ts` on disk).
+ * Resolve a TS/JS-style relative import path to an absolute file path.
  * Returns null for external packages or when the file cannot be found.
  */
 export function resolveImportPath(importFrom, fromAbs) {
@@ -40,7 +37,6 @@ export function resolveImportPath(importFrom, fromAbs) {
     const fromDir = path.dirname(fromAbs);
     const candidate = path.resolve(fromDir, importFrom);
     const declaredExt = path.extname(candidate).toLowerCase();
-    // If the import has a JS-family extension, try the TS equivalents first
     if (declaredExt && JS_TO_TS[declaredExt]) {
         const base = candidate.slice(0, candidate.length - declaredExt.length);
         for (const ext of JS_TO_TS[declaredExt]) {
@@ -49,22 +45,17 @@ export function resolveImportPath(importFrom, fromAbs) {
                 return p;
         }
     }
-    // Exact match (already has extension or points to a file)
     try {
         const stat = fs.statSync(candidate);
         if (stat.isFile())
             return candidate;
     }
-    catch {
-        // not found — try with extensions
-    }
-    // Try appending source extensions
+    catch { /* not found */ }
     for (const ext of SRC_EXTS) {
         const p = candidate + ext;
         if (fs.existsSync(p))
             return p;
     }
-    // Try index file inside the directory
     for (const ext of SRC_EXTS) {
         const p = path.join(candidate, `index${ext}`);
         if (fs.existsSync(p))
@@ -72,60 +63,126 @@ export function resolveImportPath(importFrom, fromAbs) {
     }
     return null;
 }
-/**
- * For each import in `skel`, resolve the target file and look up the symbol.
- * Returns enriched Reference Objects with resolved path, signature, and params.
- */
+/* ─── Cross-language index cache ──────────────────────────────────────────── */
+// Java/C# need a project-wide index to resolve fully-qualified imports.
+// Built lazily on first cross-language resolve, then reused for the process
+// lifetime (the MCP server is per-root, so this is safe).
+const indexCache = new Map();
+export async function getOrBuildCrossLangIndex(root) {
+    const key = path.resolve(root);
+    let p = indexCache.get(key);
+    if (p)
+        return p;
+    p = (async () => {
+        const opts = resolveOptions({ detail: "outline", emitHtml: false });
+        const files = collectSourceFiles(key, opts);
+        const skels = [];
+        for (const abs of files) {
+            const ext = path.extname(abs).toLowerCase();
+            // Only Java/C# contribute to the index (Rust resolves via direct
+            // module-path walk against the filesystem, no index needed).
+            if (ext !== ".java" && ext !== ".cs")
+                continue;
+            const rel = path.relative(key, abs).split(path.sep).join("/");
+            try {
+                skels.push(await buildSkeleton(abs, rel, opts));
+            }
+            catch { /* skip unparsable files */ }
+        }
+        return buildCrossLangIndex(skels);
+    })();
+    indexCache.set(key, p);
+    return p;
+}
+/** Test/debug hook: drop the cached index (rebuilds on next call). */
+export function clearCrossLangIndexCache() {
+    indexCache.clear();
+}
+async function lookupSymbolInTarget(targetAbs, targetRel, symbol) {
+    const opts = resolveOptions({ detail: "full", emitHtml: false });
+    try {
+        const targetSkel = await buildSkeleton(targetAbs, targetRel, opts);
+        const sym = findSymbol(targetSkel.symbols, symbol);
+        if (sym) {
+            const signature = sym.signature ?? null;
+            const out = { found: true, kind: sym.kind };
+            if (signature !== undefined)
+                out.signature = signature;
+            if (signature) {
+                const params = extractParams(signature);
+                if (params)
+                    out.params = params;
+            }
+            return out;
+        }
+    }
+    catch { /* unresolvable / parse error */ }
+    return { found: false };
+}
+async function enrichRelativeImport(imp, fromAbs, root) {
+    const isExternal = !imp.from.startsWith(".");
+    const resolvedAbs = isExternal ? null : resolveImportPath(imp.from, fromAbs);
+    const resolvedRel = resolvedAbs
+        ? path.relative(root, resolvedAbs).split(path.sep).join("/")
+        : null;
+    let enrichment = { found: false };
+    if (resolvedAbs && !imp.isSideEffect && !imp.isNamespaceImport && imp.symbol !== "*") {
+        enrichment = await lookupSymbolInTarget(resolvedAbs, resolvedRel, imp.symbol);
+    }
+    else if (resolvedAbs) {
+        enrichment = { found: true };
+    }
+    return assembleResolved(imp, resolvedAbs, resolvedRel, isExternal, enrichment);
+}
+async function enrichCrossLangImport(imp, skel, fromAbs, root, index) {
+    const target = resolveCrossLangTarget(imp, skel, fromAbs, root, index);
+    if (!target) {
+        return assembleResolved(imp, null, null, true, { found: false });
+    }
+    if (target.kind === "file") {
+        // Namespace-style (Java wildcard / C# using). Point to the first file —
+        // useful for navigation; the symbol itself isn't a specific declaration.
+        const firstRel = target.files[0];
+        const firstAbs = path.resolve(root, firstRel);
+        return assembleResolved(imp, firstAbs, firstRel, false, { found: true });
+    }
+    // Symbol-level (Java FQCN, Rust crate::path::Item)
+    const targetAbs = path.resolve(root, target.file);
+    const enrichment = await lookupSymbolInTarget(targetAbs, target.file, target.symbol);
+    return assembleResolved(imp, targetAbs, target.file, false, enrichment);
+}
+function assembleResolved(imp, resolvedAbs, resolvedRel, isExternal, enrichment) {
+    const out = {
+        ...imp,
+        resolvedPath: resolvedAbs,
+        resolvedRel,
+        found: enrichment.found,
+        importKind: isExternal ? "external" : "relative",
+    };
+    if (enrichment.kind !== undefined)
+        out.kind = enrichment.kind;
+    if (enrichment.signature !== undefined)
+        out.signature = enrichment.signature;
+    if (enrichment.params !== undefined)
+        out.params = enrichment.params;
+    return out;
+}
+/* ─── Public entry point ──────────────────────────────────────────────────── */
+const CROSS_LANG = new Set(["java", "csharp", "rust", "go"]);
 export async function resolveFileImports(skel, absPath, root) {
     if (!skel.imports || skel.imports.length === 0)
         return [];
-    const opts = resolveOptions({ detail: "full", emitHtml: false });
     const results = [];
+    // Lazy-build the cross-lang index only when actually needed.
+    let indexPromise = null;
+    const getIndex = () => (indexPromise ??= getOrBuildCrossLangIndex(root));
     for (const imp of skel.imports) {
-        const isExternal = !imp.from.startsWith(".");
-        const resolvedAbs = isExternal ? null : resolveImportPath(imp.from, absPath);
-        const resolvedRel = resolvedAbs
-            ? path.relative(root, resolvedAbs).split(path.sep).join("/")
-            : null;
-        let found = false;
-        let kind;
-        let signature;
-        let params;
-        if (resolvedAbs && !imp.isSideEffect && !imp.isNamespaceImport && imp.symbol !== "*") {
-            try {
-                const targetSkel = await buildSkeleton(resolvedAbs, resolvedRel, opts);
-                const targetSym = findSymbol(targetSkel.symbols, imp.symbol);
-                if (targetSym) {
-                    found = true;
-                    kind = targetSym.kind;
-                    signature = targetSym.signature ?? null;
-                    if (signature) {
-                        params = extractParams(signature);
-                    }
-                }
-            }
-            catch {
-                // target file unresolvable or parse error — leave found=false
-            }
+        if (CROSS_LANG.has(skel.language)) {
+            results.push(await enrichCrossLangImport(imp, skel, absPath, root, await getIndex()));
         }
-        else if (resolvedAbs) {
-            // Namespace import or side-effect: file exists = success
-            found = true;
+        else {
+            results.push(await enrichRelativeImport(imp, absPath, root));
         }
-        const resolved = {
-            ...imp,
-            resolvedPath: resolvedAbs,
-            resolvedRel,
-            found,
-            importKind: isExternal ? "external" : "relative",
-        };
-        if (kind !== undefined)
-            resolved.kind = kind;
-        if (signature !== undefined)
-            resolved.signature = signature;
-        if (params !== undefined)
-            resolved.params = params;
-        results.push(resolved);
     }
     return results;
 }