universal-ast-mapper 0.8.0 → 0.8.1

package/README.md

@@ -480,6 +480,7 @@ src/
 
 | Version | What changed |
 |---------|--------------|
+| **0.8.1** | **Cross-file graph wiring for Kotlin & C/C++** — Kotlin FQCN/package index + C/C++ `#include` resolution (with header↔impl pairing) wired into `build_symbol_graph`, `resolve_imports`, and `get_call_graph`. Fixes a parse-cache rel-path leak (stale `.file` poisoned the cross-lang index → doubled paths) and Kotlin call-graph extraction (`function_declaration` name + field-less `call_expression`). |
 | **0.8.0** | **4 new languages: C · C++ · Kotlin · Swift** — symbol extraction + imports parsing. C++ tracks access_specifier through class bodies. Kotlin handles `package`/`object`/`data class`. Swift handles `class`/`struct`/`enum` (all under `class_declaration`) and `protocol_declaration`. Ruby grammar in tree-sitter-wasms@0.1.13 is unstable — skipped. |
 | **0.7.0** | Go full resolution (reads `go.mod`, resolves package-as-directory) · C# reverse `calledBy` via call-site scanning · `csharpTypes` index lets `using` directives resolve to specific types · 4-suite test harness (smoke + graph-smoke + resolver-smoke + callgraph-smoke) |
 | **0.6.0** | **3 new languages: Rust · Java · C#** (extractors + import parsing) · cross-language resolver in `crosslang.ts` (Java FQCN index, C# namespace index, Rust `crate::` module walk) · symbol-graph `imports` edges + `resolveFileImports` enrichment + `get_call_graph` callee resolution rewired through it · Java `package` and C# `namespace` captured as directives |

package/dist/callgraph.js

@@ -6,7 +6,7 @@ import { resolveOptions, loadProjectConfig } from "./config.js";
 import { detectLanguage } from "./registry.js";
 import { resolveImportPath, getOrBuildCrossLangIndex } from "./resolver.js";
 import { resolveCrossLangTarget } from "./crosslang.js";
-const CROSS_LANG = new Set(["java", "csharp", "rust", "go"]);
+const CROSS_LANG = new Set(["java", "csharp", "rust", "go", "kotlin", "c", "cpp"]);
 function pushCall(out, callee, anchor) {
     if (callee && anchor)
         out.push({ callee, line: anchor.startPosition.row + 1 });
@@ -54,6 +54,20 @@ function collectCalls(node, out) {
             }
             pushCall(out, callee, fn);
         }
+        else {
+            // Kotlin: call_expression has no `function` field — the callee is the
+            // first named child (a simple_identifier for `Foo(...)` / a bare call,
+            // or a navigation_expression for `obj.method(...)`).
+            const callee0 = node.namedChild(0);
+            if (callee0) {
+                if (callee0.type === "simple_identifier" || callee0.type === "identifier") {
+                    pushCall(out, callee0.text, callee0);
+                }
+                else if (callee0.type === "navigation_expression") {
+                    pushCall(out, callee0.text.replace(/\s+/g, ""), callee0);
+                }
+            }
+        }
     }
     // ── Java method invocation
     else if (t === "method_invocation") {
@@ -110,8 +124,16 @@ const FUNCTION_NODE_TYPES = new Set([
 function findFunctionNode(root, name) {
     function walk(node) {
         if (FUNCTION_NODE_TYPES.has(node.type)) {
-            if (node.childForFieldName("name")?.text === name)
+            const named = node.childForFieldName("name");
+            if (named?.text === name)
                 return node;
+            // Kotlin: function_declaration exposes its name as a simple_identifier
+            // child, not via a `name` field.
+            if (!named && node.type === "function_declaration") {
+                const id = node.namedChild(0);
+                if (id?.type === "simple_identifier" && id.text === name)
+                    return node;
+            }
         }
         // const foo = () => ... | const foo = function() ...
         if (node.type === "variable_declarator") {

package/dist/crosslang.js

@@ -24,6 +24,8 @@ export function buildCrossLangIndex(skeletons) {
         javaPackages: new Map(),
         csharpNamespaces: new Map(),
         csharpTypes: new Map(),
+        kotlinFqcn: new Map(),
+        kotlinPackages: new Map(),
     };
     for (const skel of skeletons) {
         if (skel.language === "java") {
@@ -55,6 +57,17 @@ export function buildCrossLangIndex(skeletons) {
                 }
             }
         }
+        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);
+            }
+        }
     }
     return index;
 }
@@ -262,6 +275,47 @@ export function resolveGoImport(importFrom, fromAbs, projectRoot) {
 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.
@@ -301,8 +355,31 @@ export function resolveCrossLangTarget(imp, skel, fromAbs, projectRoot, index) {
         const files = resolveGoImport(imp.from, fromAbs, projectRoot);
         if (!files || files.length === 0)
             return null;
-        // Exclude self (a file in package X importing X is unusual but possible
-        // for cyclic / generated cases — don't draw a self-edge).
+        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;

package/dist/graph.js

@@ -139,7 +139,10 @@ export function buildSymbolGraph(skeletons, root) {
             else if (skel.language === "java" ||
                 skel.language === "csharp" ||
                 skel.language === "rust" ||
-                skel.language === "go") {
+                skel.language === "go" ||
+                skel.language === "kotlin" ||
+                skel.language === "c" ||
+                skel.language === "cpp") {
                 wireCrossLangImport(skel, imp, fromFileAbs, root, crossIndex, exportedSymbolMap, edges);
             }
         }

package/dist/resolver.js

@@ -81,7 +81,7 @@ export async function getOrBuildCrossLangIndex(root) {
             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")
+            if (ext !== ".java" && ext !== ".cs" && ext !== ".kt" && ext !== ".kts")
                 continue;
             const rel = path.relative(key, abs).split(path.sep).join("/");
             try {
@@ -168,7 +168,7 @@ function assembleResolved(imp, resolvedAbs, resolvedRel, isExternal, enrichment)
     return out;
 }
 /* ─── Public entry point ──────────────────────────────────────────────────── */
-const CROSS_LANG = new Set(["java", "csharp", "rust", "go"]);
+const CROSS_LANG = new Set(["java", "csharp", "rust", "go", "kotlin", "c", "cpp"]);
 export async function resolveFileImports(skel, absPath, root) {
     if (!skel.imports || skel.imports.length === 0)
         return [];

package/dist/skeleton.js

@@ -48,10 +48,15 @@ export async function buildSkeleton(absPath, relPath, opts) {
     if (stat.size > opts.maxFileBytes) {
         throw new Error(`File is ${stat.size} bytes, exceeds maxFileBytes (${opts.maxFileBytes}). Increase the limit to parse it.`);
     }
-    // Return cached result if file hasn't changed
+    // Return cached result if file hasn't changed. The cached SkeletonFile's
+    // `.file` is whatever relPath the first caller used; the same absolute file
+    // can be requested under a different root (different relPath), so override
+    // `.file` per call to avoid leaking a stale rel path into callers/indexes.
     const cached = getCached(absPath, opts.detail);
-    if (cached)
-        return cached;
+    if (cached) {
+        const wantFile = relPath.split(path.sep).join("/");
+        return cached.file === wantFile ? cached : { ...cached, file: wantFile };
+    }
     const source = fs.readFileSync(absPath, "utf8");
     const root = await parseSource(entry.grammar, source);
     let symbols = entry.extract(root, source);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "universal-ast-mapper",
-  "version": "0.8.0",
+  "version": "0.8.1",
   "description": "MCP server that maps source files into a normalized code skeleton (JSON + HTML) using tree-sitter.",
   "type": "module",
   "main": "dist/index.js",