universal-ast-mapper 0.8.0 → 0.8.2

package/README.md

@@ -10,12 +10,12 @@ Built on [tree-sitter](https://tree-sitter.github.io/) WASM grammars. Zero regex
 |--------------------------|:-----:|:------:|:---:|:----:|:----:|:---:|:---:|:---:|:---:|:-----:|
 | Symbol extraction        | ✅    | ✅     | ✅  | ✅   | ✅   | ✅  | ✅  | ✅  | ✅  | ✅    |
 | Imports parsing          | ✅    | ✅     | ✅  | ✅   | ✅   | ✅  | ✅  | ✅  | ✅  | ✅    |
-| Graph `imports` edges    | ✅    | ✅     | ✅  | ✅   | ✅   | ✅  | —   | —   | —   | —     |
-| `resolve_imports` enrich | ✅    | ✅     | ✅  | ✅   | ✅   | ✅  | —   | —   | —   | —     |
-| Call graph callee origin | ✅    | ✅     | ✅  | ✅   | ✅   | ✅  | —   | —   | —   | —     |
-| Reverse `calledBy`       | ✅    | ✅     | ✅  | ✅   | ✅   | ✅  | —   | —   | —   | —     |
+| Graph `imports` edges    | ✅    | ✅     | ✅  | ✅   | ✅   | ✅  | ✅  | ✅  | ✅  | ✅    |
+| `resolve_imports` enrich | ✅    | ✅     | ✅  | ✅   | ✅   | ✅  | ✅  | ✅  | ✅  | ✅    |
+| Call graph callee origin | ✅    | ✅     | ✅  | ✅   | ✅   | ✅  | —   | —   | ✅  | —     |
+| Reverse `calledBy`       | ✅    | ✅     | ✅  | ✅   | ✅   | ✅  | —   | —   | ✅  | —     |
 
-> v0.8.0 introduces **symbol extraction + imports parsing** for C / C++ / Kotlin / Swift. Graph/resolver/callgraph dispatch for these four lands in a follow-up release. (Ruby grammar in `tree-sitter-wasms@0.1.13` is unstable and was skipped.)
+> As of v0.8.2, all four v0.8.0 languages have **cross-file graph + resolver** wiring: Kotlin (FQCN/package index), C/C++ (`#include` with header↔impl pairing), and Swift (module = directory under `Sources/`). Call-graph callee origin is resolved for Kotlin; for C/C++/Swift it stays limited because their imports don't name individual symbols. (Ruby grammar in `tree-sitter-wasms@0.1.13` is unstable and was skipped.)
 
 Each language uses the resolution strategy that fits it:
 - **TS/JS/Python** — relative paths (`./foo`, `..mod`) resolved against the importing file's directory, with TS-ESM `.js` → `.ts` rewriting.
@@ -23,6 +23,8 @@ Each language uses the resolution strategy that fits it:
 - **Rust** — `Cargo.toml` ancestor → `crate::` / `self::` / `super::` walks; supports `mod.rs` + Rust-2018 sibling-dir style.
 - **Java** — project-wide FQCN index (`package + "." + className → file`) built lazily on first cross-lang call; supports wildcard imports.
 - **C#** — namespace-to-files index plus a `<ns>.<TypeName>` index so `using App.Models` + `new Inventory()` resolves to the right file.
+- **Kotlin** — project-wide FQCN index (`package + "." + ClassName → file`), like Java; wildcard `import pkg.*` pulls every file in the package.
+- **C / C++** — `#include "..."` resolved against the including file's directory; headers auto-paired with same-name `.c`/`.cpp`/`.cc`/`.cxx` impl files. `<system>` includes stay external.
 
 For C# and Go (where imports don't name the called symbol), reverse `calledBy` falls back to **call-site scanning** of candidate files.
 
@@ -290,7 +292,7 @@ Parse a function body → extract every call expression, resolve callees via the
 ```
 
 Supports all 8 languages with per-language call extraction (TS/JS `member_expression`, Rust `field_expression`/`scoped_identifier`, Java `method_invocation`, C# `invocation_expression`, etc.) and constructor calls (`new Foo`).  
-Handles TS/JS destructured aliases (`const { sign } = jwt`), Java FQCN imports, C# `using` namespaces (via project-wide type index), Rust `use crate::path::Item`, Go `pkg.Func` (via go.mod module path). Reverse `calledBy` uses call-site scanning for C# and Go where import statements don't name the called symbol.
+Handles TS/JS destructured aliases (`const { sign } = jwt`), Java FQCN imports, C# `using` namespaces (via project-wide type index), Rust `use crate::path::Item`, Go `pkg.Func` (via go.mod module path), Kotlin FQCN/package imports, C/C++ `#include`, and Swift module imports (`import <Module>` → files under `Sources/<Module>/`). Reverse `calledBy` uses call-site scanning for C# and Go where import statements don't name the called symbol.
 
 **Params:** `path`, `function`, `scanDir`
 
@@ -480,6 +482,8 @@ src/
 
 | Version | What changed |
 |---------|--------------|
+| **0.8.2** | **Swift cross-file wiring** — `import <Module>` resolves to that module's files (module = the `Sources/<Module>/` directory, else parent dir), wired into `build_symbol_graph` + `resolve_imports`. System modules (Foundation, UIKit, …) stay external. Completes cross-file graph/resolver support for all four v0.8.0 languages. |
+| **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", "swift"]);
 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,9 @@ export function buildCrossLangIndex(skeletons) {
         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") {
@@ -55,9 +58,43 @@ 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);
+            }
+        }
+        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);
@@ -262,6 +299,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,12 +379,47 @@ 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;
+        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;
 }

package/dist/graph.js

@@ -139,7 +139,11 @@ 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" ||
+                skel.language === "swift") {
                 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" && ext !== ".swift")
                 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", "swift"]);
 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.2",
   "description": "MCP server that maps source files into a normalized code skeleton (JSON + HTML) using tree-sitter.",
   "type": "module",
   "main": "dist/index.js",