universal-ast-mapper 0.5.2 → 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/index.js

@@ -46,7 +46,7 @@ function errorText(message) {
 }
 const server = new McpServer({
     name: "universal-ast-mapper",
-    version: "0.5.2",
+    version: "0.5.3",
 });
 /* ----------------------- tool: list_supported_languages ----------------------- */
 server.registerTool("list_supported_languages", {

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;