universal-ast-mapper 0.7.0 → 0.8.1

package/README.md

@@ -4,16 +4,18 @@ An **MCP server + CLI tool** that turns source code into structured, machine-rea
 
 Built on [tree-sitter](https://tree-sitter.github.io/) WASM grammars. Zero regex guessing — real AST parsing.
 
-**Supported languages:** TypeScript · TSX · JavaScript (ESM/CJS) · Python · Go · Rust · Java · C#
+**Supported languages:** TypeScript · TSX · JavaScript (ESM/CJS) · Python · Go · Rust · Java · C# · C · C++ · Kotlin · Swift
 
-| Capability               | TS/JS | Python | Go  | Rust | Java | C#  |
-|--------------------------|:-----:|:------:|:---:|:----:|:----:|:---:|
-| Symbol extraction        | ✅    | ✅     | ✅  | ✅   | ✅   | ✅  |
-| Imports parsing          | ✅    | ✅     | ✅  | ✅   | ✅   | ✅  |
-| Graph `imports` edges    | ✅    | ✅     | ✅  | ✅   | ✅   | ✅  |
-| `resolve_imports` enrich | ✅    | ✅     | ✅  | ✅   | ✅   | ✅  |
-| Call graph callee origin | ✅    | ✅     | ✅  | ✅   | ✅   | ✅  |
-| Reverse `calledBy`       | ✅    | ✅     | ✅  | ✅   | ✅   | ✅  |
+| Capability               | TS/JS | Python | Go  | Rust | Java | C#  | C   | C++ | Kt  | Swift |
+|--------------------------|:-----:|:------:|:---:|:----:|:----:|:---:|:---:|:---:|:---:|:-----:|
+| Symbol extraction        | ✅    | ✅     | ✅  | ✅   | ✅   | ✅  | ✅  | ✅  | ✅  | ✅    |
+| Imports parsing          | ✅    | ✅     | ✅  | ✅   | ✅   | ✅  | ✅  | ✅  | ✅  | ✅    |
+| 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.)
 
 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.
@@ -478,6 +480,8 @@ 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 |
 | **0.5.3** | Auto-install `/ast-map` Claude Code skill on `npm install` · `postinstall` writes `~/.claude/skills/ast-map/SKILL.md` + registers trigger in `CLAUDE.md` (idempotent, CI-safe) |

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/extractors/c.js

@@ -0,0 +1,204 @@
+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;
+}
+/** Recursively unwrap a declarator chain to get the identifier text. */
+function nameFromDeclarator(node) {
+    if (!node)
+        return null;
+    switch (node.type) {
+        case "identifier":
+        case "field_identifier":
+        case "type_identifier":
+            return node.text;
+        case "pointer_declarator":
+        case "array_declarator":
+        case "parenthesized_declarator":
+            return nameFromDeclarator(node.childForFieldName("declarator"));
+        case "function_declarator": {
+            const d = node.childForFieldName("declarator");
+            return nameFromDeclarator(d);
+        }
+        case "init_declarator":
+            return nameFromDeclarator(node.childForFieldName("declarator"));
+        default:
+            // best-effort: find first identifier-like child
+            for (let i = 0; i < node.namedChildCount; i++) {
+                const c = node.namedChild(i);
+                if (c && (c.type === "identifier" || c.type === "field_identifier" || c.type === "type_identifier"))
+                    return c.text;
+            }
+            return null;
+    }
+}
+function hasStaticStorage(node) {
+    for (let i = 0; i < node.childCount; i++) {
+        const c = node.child(i);
+        if (c && c.type === "storage_class_specifier" && c.text === "static")
+            return true;
+    }
+    return false;
+}
+/* ─── imports (#include) ──────────────────────────────────────────────────── */
+export function extractImportsC(root, _source) {
+    const out = [];
+    for (const child of namedChildren(root)) {
+        if (child.type !== "preproc_include")
+            continue;
+        const pathNode = childOfType(child, "system_lib_string") ?? childOfType(child, "string_literal");
+        if (!pathNode)
+            continue;
+        const raw = pathNode.text.replace(/^[<"]|[>"]$/g, "");
+        const base = raw.split("/").pop() ?? raw;
+        const sym = base.replace(/\.[hH]$|\.hpp$|\.hxx$|\.hh$/, "");
+        out.push({ symbol: sym, from: raw });
+    }
+    return out;
+}
+/* ─── symbol extraction ───────────────────────────────────────────────────── */
+export function extractC(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_specifier":
+        case "union_specifier": {
+            const name = nameOf(node);
+            if (!name)
+                return null;
+            const body = node.childForFieldName("body");
+            return makeSymbol({
+                name,
+                kind: "struct",
+                node,
+                rawKind: node.type,
+                doc: leadingComment(node),
+                children: body ? structFields(body) : [],
+            });
+        }
+        case "enum_specifier": {
+            const name = nameOf(node);
+            if (!name)
+                return null;
+            return makeSymbol({
+                name,
+                kind: "enum",
+                node,
+                rawKind: node.type,
+                doc: leadingComment(node),
+            });
+        }
+        case "function_definition": {
+            const decl = node.childForFieldName("declarator");
+            const name = nameFromDeclarator(decl);
+            if (!name)
+                return null;
+            const isStatic = hasStaticStorage(node);
+            return makeSymbol({
+                name,
+                kind: "function",
+                node,
+                rawKind: node.type,
+                signature: headerSignature(node, node.childForFieldName("body")),
+                visibility: isStatic ? "private" : "public",
+                exported: !isStatic,
+                doc: leadingComment(node),
+            });
+        }
+        case "declaration": {
+            // top-level variable/function declarations (prototypes, externs, etc.)
+            const decl = node.childForFieldName("declarator");
+            const name = nameFromDeclarator(decl);
+            if (!name)
+                return null;
+            // skip function prototypes — focus on real defs (function_definition)
+            if (decl && containsFunctionDeclarator(decl))
+                return null;
+            return makeSymbol({
+                name,
+                kind: "var",
+                node,
+                rawKind: node.type,
+                signature: node.text.replace(/\s+/g, " ").replace(/;$/, "").trim(),
+                visibility: hasStaticStorage(node) ? "private" : "public",
+                exported: !hasStaticStorage(node),
+            });
+        }
+        case "preproc_def":
+        case "preproc_function_def": {
+            const name = nameOf(node);
+            if (!name)
+                return null;
+            return makeSymbol({
+                name,
+                kind: "const",
+                node,
+                rawKind: node.type,
+                signature: node.text.replace(/\s+/g, " ").trim(),
+            });
+        }
+        case "type_definition": {
+            // typedef — name is in the declarator (last identifier)
+            const decl = node.childForFieldName("declarator");
+            const name = nameFromDeclarator(decl);
+            if (!name)
+                return null;
+            return makeSymbol({
+                name,
+                kind: "type",
+                node,
+                rawKind: node.type,
+                signature: node.text.replace(/\s+/g, " ").replace(/;$/, "").trim(),
+            });
+        }
+        default:
+            return null;
+    }
+}
+function containsFunctionDeclarator(node) {
+    if (node.type === "function_declarator")
+        return true;
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const c = node.namedChild(i);
+        if (c && containsFunctionDeclarator(c))
+            return true;
+    }
+    return false;
+}
+function structFields(body) {
+    const out = [];
+    for (const field of namedChildren(body)) {
+        if (field.type !== "field_declaration")
+            continue;
+        const decl = field.childForFieldName("declarator");
+        const name = nameFromDeclarator(decl);
+        if (!name)
+            continue;
+        out.push(makeSymbol({
+            name,
+            kind: "field",
+            node: field,
+            rawKind: field.type,
+            signature: field.text.replace(/\s+/g, " ").replace(/;$/, "").trim(),
+        }));
+    }
+    return out;
+}

package/dist/extractors/cpp.js

@@ -0,0 +1,272 @@
+import { namedChildren, nameOf, headerSignature, leadingComment } from "../parser.js";
+import { makeSymbol } from "./common.js";
+/* ─── helpers (shared with C extractor in spirit but kept local) ──────────── */
+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;
+}
+function nameFromDeclarator(node) {
+    if (!node)
+        return null;
+    switch (node.type) {
+        case "identifier":
+        case "field_identifier":
+        case "type_identifier":
+            return node.text;
+        case "pointer_declarator":
+        case "array_declarator":
+        case "parenthesized_declarator":
+        case "reference_declarator":
+            return nameFromDeclarator(node.childForFieldName("declarator") ?? node.namedChild(0));
+        case "function_declarator":
+        case "init_declarator":
+            return nameFromDeclarator(node.childForFieldName("declarator"));
+        case "qualified_identifier": {
+            // Foo::bar — use "bar" as the leaf name
+            const last = node.childForFieldName("name");
+            return last ? last.text : node.text;
+        }
+        case "operator_name":
+        case "destructor_name":
+            return node.text;
+        default:
+            for (let i = 0; i < node.namedChildCount; i++) {
+                const c = node.namedChild(i);
+                if (c && (c.type === "identifier" || c.type === "field_identifier" || c.type === "type_identifier"))
+                    return c.text;
+            }
+            return null;
+    }
+}
+function containsFunctionDeclarator(node) {
+    if (node.type === "function_declarator")
+        return true;
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const c = node.namedChild(i);
+        if (c && containsFunctionDeclarator(c))
+            return true;
+    }
+    return false;
+}
+function hasStaticStorage(node) {
+    for (let i = 0; i < node.childCount; i++) {
+        const c = node.child(i);
+        if (c && c.type === "storage_class_specifier" && c.text === "static")
+            return true;
+    }
+    return false;
+}
+/* ─── imports (#include) ──────────────────────────────────────────────────── */
+export function extractImportsCpp(root, _source) {
+    const out = [];
+    const visit = (n) => {
+        for (const c of namedChildren(n)) {
+            if (c.type === "preproc_include") {
+                const p = childOfType(c, "system_lib_string") ?? childOfType(c, "string_literal");
+                if (p) {
+                    const raw = p.text.replace(/^[<"]|[>"]$/g, "");
+                    const base = raw.split("/").pop() ?? raw;
+                    out.push({ symbol: base.replace(/\.[hH](pp|xx|h)?$/, ""), from: raw });
+                }
+            }
+            else if (c.type === "namespace_definition" || c.type === "linkage_specification") {
+                const body = c.childForFieldName("body");
+                if (body)
+                    visit(body);
+            }
+        }
+    };
+    visit(root);
+    return out;
+}
+/* ─── symbol extraction ───────────────────────────────────────────────────── */
+export function extractCpp(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 "namespace_definition":
+        case "linkage_specification": {
+            // Recurse into body, flattening namespace contents to top level.
+            const body = node.childForFieldName("body");
+            return body ? collect(namedChildren(body)) : null;
+        }
+        case "class_specifier": {
+            const name = nameOf(node);
+            if (!name)
+                return null;
+            const body = node.childForFieldName("body");
+            return makeSymbol({
+                name,
+                kind: "class",
+                node,
+                rawKind: node.type,
+                doc: leadingComment(node),
+                children: body ? classMembers(body, "private") : [],
+            });
+        }
+        case "struct_specifier": {
+            const name = nameOf(node);
+            if (!name)
+                return null;
+            const body = node.childForFieldName("body");
+            return makeSymbol({
+                name,
+                kind: "struct",
+                node,
+                rawKind: node.type,
+                doc: leadingComment(node),
+                children: body ? classMembers(body, "public") : [],
+            });
+        }
+        case "enum_specifier": {
+            const name = nameOf(node);
+            if (!name)
+                return null;
+            return makeSymbol({
+                name,
+                kind: "enum",
+                node,
+                rawKind: node.type,
+                doc: leadingComment(node),
+            });
+        }
+        case "function_definition": {
+            const decl = node.childForFieldName("declarator");
+            const name = nameFromDeclarator(decl);
+            if (!name)
+                return null;
+            return makeSymbol({
+                name,
+                kind: "function",
+                node,
+                rawKind: node.type,
+                signature: headerSignature(node, node.childForFieldName("body")),
+                visibility: hasStaticStorage(node) ? "private" : "public",
+                exported: !hasStaticStorage(node),
+                doc: leadingComment(node),
+            });
+        }
+        case "template_declaration": {
+            // The actual declaration is buried; recurse to find it.
+            for (let i = 0; i < node.namedChildCount; i++) {
+                const c = node.namedChild(i);
+                if (!c)
+                    continue;
+                if (c.type === "class_specifier" ||
+                    c.type === "struct_specifier" ||
+                    c.type === "function_definition" ||
+                    c.type === "declaration") {
+                    const res = handle(c);
+                    if (res)
+                        return res;
+                }
+            }
+            return null;
+        }
+        case "alias_declaration":
+        case "type_definition": {
+            const decl = node.childForFieldName("declarator");
+            const name = nameOf(node) ?? nameFromDeclarator(decl);
+            if (!name)
+                return null;
+            return makeSymbol({
+                name,
+                kind: "type",
+                node,
+                rawKind: node.type,
+                signature: node.text.replace(/\s+/g, " ").replace(/;$/, "").trim(),
+            });
+        }
+        case "declaration": {
+            const decl = node.childForFieldName("declarator");
+            const name = nameFromDeclarator(decl);
+            if (!name)
+                return null;
+            if (decl && containsFunctionDeclarator(decl))
+                return null; // prototype
+            return makeSymbol({
+                name,
+                kind: "var",
+                node,
+                rawKind: node.type,
+                signature: node.text.replace(/\s+/g, " ").replace(/;$/, "").trim(),
+            });
+        }
+        case "preproc_def":
+        case "preproc_function_def": {
+            const name = nameOf(node);
+            if (!name)
+                return null;
+            return makeSymbol({
+                name,
+                kind: "const",
+                node,
+                rawKind: node.type,
+            });
+        }
+        default:
+            return null;
+    }
+}
+/** Walk class/struct body, tracking the current access_specifier (default given). */
+function classMembers(body, defaultAccess) {
+    let current = defaultAccess;
+    const out = [];
+    for (let i = 0; i < body.childCount; i++) {
+        const c = body.child(i);
+        if (!c)
+            continue;
+        if (c.type === "access_specifier") {
+            current = /\bpublic\b/.test(c.text) ? "public" : "private";
+            continue;
+        }
+        if (!c.isNamed)
+            continue;
+        if (c.type === "field_declaration") {
+            const dec = c.childForFieldName("declarator");
+            const name = nameFromDeclarator(dec);
+            if (!name)
+                continue;
+            const isFunc = dec && containsFunctionDeclarator(dec);
+            out.push(makeSymbol({
+                name,
+                kind: isFunc ? "method" : "field",
+                node: c,
+                rawKind: c.type,
+                signature: c.text.replace(/\s+/g, " ").replace(/;$/, "").trim(),
+                visibility: current,
+            }));
+        }
+        else if (c.type === "function_definition") {
+            const dec = c.childForFieldName("declarator");
+            const name = nameFromDeclarator(dec);
+            if (!name)
+                continue;
+            out.push(makeSymbol({
+                name,
+                kind: "method",
+                node: c,
+                rawKind: c.type,
+                signature: headerSignature(c, c.childForFieldName("body")),
+                visibility: current,
+            }));
+        }
+    }
+    return out;
+}

package/dist/extractors/kotlin.js

@@ -0,0 +1,159 @@
+import { namedChildren, 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;
+}
+function firstChildOfTypes(node, types) {
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const c = node.namedChild(i);
+        if (c && types.has(c.type))
+            return c;
+    }
+    return null;
+}
+const TYPE_NAME_NODES = new Set(["type_identifier", "simple_identifier"]);
+const SIMPLE_NAME_NODES = new Set(["simple_identifier"]);
+function modifiersText(node) {
+    const m = childOfType(node, "modifiers");
+    return m ? m.text : "";
+}
+function vis(node) {
+    const m = modifiersText(node);
+    if (/\b(private|protected|internal)\b/.test(m))
+        return "private";
+    return "public"; // Kotlin default is public
+}
+function exported(node) {
+    const m = modifiersText(node);
+    if (/\b(private|protected|internal)\b/.test(m))
+        return false;
+    return true;
+}
+function classKind(node) {
+    const m = modifiersText(node);
+    if (/\bdata\b/.test(node.text.slice(0, 80)))
+        return "class";
+    if (/\benum\b/.test(node.text.slice(0, 80)))
+        return "enum";
+    return "class";
+}
+/* ─── imports + package ───────────────────────────────────────────────────── */
+export function extractDirectivesKotlin(root, _source) {
+    for (const c of namedChildren(root)) {
+        if (c.type === "package_header") {
+            const id = childOfType(c, "identifier");
+            if (id)
+                return [`package:${id.text}`];
+        }
+    }
+    return [];
+}
+export function extractImportsKotlin(root, _source) {
+    const out = [];
+    const list = childOfType(root, "import_list");
+    if (!list)
+        return out;
+    for (const h of namedChildren(list)) {
+        if (h.type !== "import_header")
+            continue;
+        const id = childOfType(h, "identifier");
+        if (!id)
+            continue;
+        const isWildcard = /\.\*\s*$/.test(h.text);
+        const from = id.text;
+        const sym = isWildcard ? "*" : (from.split(".").pop() ?? from);
+        out.push({ symbol: sym, from, isNamespaceImport: isWildcard });
+    }
+    return out;
+}
+/* ─── symbol extraction ───────────────────────────────────────────────────── */
+export function extractKotlin(root, _source) {
+    return collect(namedChildren(root), false);
+}
+function collect(nodes, insideClass) {
+    const out = [];
+    for (const n of nodes) {
+        const res = handle(n, insideClass);
+        if (res)
+            out.push(res);
+    }
+    return out;
+}
+function handle(node, insideClass) {
+    switch (node.type) {
+        case "class_declaration": {
+            const nameNode = firstChildOfTypes(node, TYPE_NAME_NODES);
+            if (!nameNode)
+                return null;
+            const body = childOfType(node, "class_body") ?? childOfType(node, "enum_class_body");
+            return makeSymbol({
+                name: nameNode.text,
+                kind: classKind(node),
+                node,
+                rawKind: node.type,
+                visibility: vis(node),
+                exported: exported(node),
+                doc: leadingComment(node),
+                children: body ? collect(namedChildren(body), true) : [],
+            });
+        }
+        case "object_declaration": {
+            const nameNode = firstChildOfTypes(node, TYPE_NAME_NODES);
+            if (!nameNode)
+                return null;
+            const body = childOfType(node, "class_body");
+            return makeSymbol({
+                name: nameNode.text,
+                kind: "class",
+                node,
+                rawKind: node.type,
+                visibility: vis(node),
+                exported: exported(node),
+                doc: leadingComment(node),
+                children: body ? collect(namedChildren(body), true) : [],
+            });
+        }
+        case "function_declaration": {
+            const nameNode = firstChildOfTypes(node, SIMPLE_NAME_NODES);
+            if (!nameNode)
+                return null;
+            const body = childOfType(node, "function_body");
+            return makeSymbol({
+                name: nameNode.text,
+                kind: insideClass ? "method" : "function",
+                node,
+                rawKind: node.type,
+                signature: headerSignature(node, body),
+                visibility: vis(node),
+                exported: exported(node),
+                doc: leadingComment(node),
+            });
+        }
+        case "property_declaration": {
+            // variable_declaration → simple_identifier
+            const vd = childOfType(node, "variable_declaration");
+            const nameNode = vd ? firstChildOfTypes(vd, SIMPLE_NAME_NODES) : firstChildOfTypes(node, SIMPLE_NAME_NODES);
+            if (!nameNode)
+                return null;
+            const m = modifiersText(node);
+            const kind = insideClass ? "field" : (/\bconst\b/.test(m) ? "const" : "var");
+            return makeSymbol({
+                name: nameNode.text,
+                kind,
+                node,
+                rawKind: node.type,
+                signature: node.text.replace(/\s+/g, " ").trim(),
+                visibility: vis(node),
+                exported: exported(node),
+            });
+        }
+        default:
+            return null;
+    }
+}

package/dist/extractors/swift.js

@@ -0,0 +1,192 @@
+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;
+}
+function modifiersText(node) {
+    const m = childOfType(node, "modifiers");
+    return m ? m.text : "";
+}
+function vis(node) {
+    const m = modifiersText(node);
+    if (/\b(private|fileprivate)\b/.test(m))
+        return "private";
+    return "public"; // treat internal/public/open as public
+}
+function exported(node) {
+    const m = modifiersText(node);
+    return /\b(public|open)\b/.test(m) || !/\b(private|fileprivate|internal)\b/.test(m);
+}
+/** Swift uses class_declaration for `class`, `struct`, `enum`, `actor`, `extension`. */
+function classDeclKind(node) {
+    const head = node.text.slice(0, 80);
+    if (/\bstruct\b/.test(head))
+        return "struct";
+    if (/\benum\b/.test(head))
+        return "enum";
+    const body = childOfType(node, "enum_class_body");
+    if (body)
+        return "enum";
+    return "class";
+}
+/* ─── imports ─────────────────────────────────────────────────────────────── */
+export function extractImportsSwift(root, _source) {
+    const out = [];
+    for (const c of namedChildren(root)) {
+        if (c.type !== "import_declaration")
+            continue;
+        const id = childOfType(c, "identifier");
+        const text = id ? id.text : c.text.replace(/^import\s+/, "").trim();
+        out.push({ symbol: text.split(".").pop() ?? text, from: text });
+    }
+    return out;
+}
+/* ─── symbol extraction ───────────────────────────────────────────────────── */
+export function extractSwift(root, _source) {
+    return collect(namedChildren(root), false);
+}
+function collect(nodes, insideClass) {
+    const out = [];
+    for (const n of nodes) {
+        const res = handle(n, insideClass);
+        if (res)
+            out.push(res);
+    }
+    return out;
+}
+function handle(node, insideClass) {
+    switch (node.type) {
+        case "class_declaration": {
+            const name = nameOf(node);
+            if (!name)
+                return null;
+            const kind = classDeclKind(node);
+            const body = childOfType(node, "class_body") ?? childOfType(node, "enum_class_body");
+            return makeSymbol({
+                name,
+                kind,
+                node,
+                rawKind: node.type,
+                visibility: vis(node),
+                exported: exported(node),
+                doc: leadingComment(node),
+                children: body ? collect(namedChildren(body), true) : [],
+            });
+        }
+        case "protocol_declaration": {
+            const name = nameOf(node);
+            if (!name)
+                return null;
+            const body = childOfType(node, "protocol_body");
+            const kids = [];
+            if (body) {
+                for (const m of namedChildren(body)) {
+                    if (m.type === "protocol_function_declaration") {
+                        const n = nameOf(m);
+                        if (n) {
+                            kids.push(makeSymbol({
+                                name: n,
+                                kind: "method",
+                                node: m,
+                                rawKind: m.type,
+                                signature: headerSignature(m, null),
+                                visibility: "public",
+                                exported: true,
+                            }));
+                        }
+                    }
+                }
+            }
+            return makeSymbol({
+                name,
+                kind: "interface",
+                node,
+                rawKind: node.type,
+                visibility: vis(node),
+                exported: exported(node),
+                doc: leadingComment(node),
+                children: kids,
+            });
+        }
+        case "function_declaration": {
+            const name = nameOf(node);
+            if (!name)
+                return null;
+            const body = childOfType(node, "function_body");
+            return makeSymbol({
+                name,
+                kind: insideClass ? "method" : "function",
+                node,
+                rawKind: node.type,
+                signature: headerSignature(node, body),
+                visibility: vis(node),
+                exported: exported(node),
+                doc: leadingComment(node),
+            });
+        }
+        case "init_declaration": {
+            return makeSymbol({
+                name: "init",
+                kind: "method",
+                node,
+                rawKind: node.type,
+                signature: headerSignature(node, childOfType(node, "function_body")),
+                visibility: vis(node),
+                exported: exported(node),
+            });
+        }
+        case "property_declaration": {
+            // name is `pattern` field; the pattern contains simple_identifier
+            const pat = node.childForFieldName("name");
+            let name = null;
+            if (pat) {
+                const id = pat.type === "simple_identifier" ? pat : findFirstNamed(pat, "simple_identifier");
+                name = id ? id.text : null;
+            }
+            if (!name)
+                return null;
+            const isLet = /\blet\b/.test(node.text.slice(0, 30));
+            return makeSymbol({
+                name,
+                kind: insideClass ? "field" : (isLet ? "const" : "var"),
+                node,
+                rawKind: node.type,
+                signature: node.text.replace(/\s+/g, " ").trim(),
+                visibility: vis(node),
+                exported: exported(node),
+            });
+        }
+        case "enum_entry": {
+            const name = nameOf(node);
+            if (!name)
+                return null;
+            return makeSymbol({
+                name,
+                kind: "field",
+                node,
+                rawKind: node.type,
+            });
+        }
+        default:
+            return null;
+    }
+}
+function findFirstNamed(node, type) {
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const c = node.namedChild(i);
+        if (!c)
+            continue;
+        if (c.type === type)
+            return c;
+        const deep = findFirstNamed(c, type);
+        if (deep)
+            return deep;
+    }
+    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/registry.js

@@ -5,6 +5,10 @@ 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";
+import { extractC, extractImportsC } from "./extractors/c.js";
+import { extractCpp, extractImportsCpp } from "./extractors/cpp.js";
+import { extractKotlin, extractDirectivesKotlin, extractImportsKotlin } from "./extractors/kotlin.js";
+import { extractSwift, extractImportsSwift } from "./extractors/swift.js";
 const TS_ENTRY = (language, grammar) => ({
     language,
     grammar,
@@ -26,19 +30,30 @@ const BY_EXT = {
     ".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,
+        language: "java", grammar: "java",
+        extract: extractJava, extractDirectives: extractDirectivesJava, extractImports: extractImportsJava,
     },
     ".cs": {
-        language: "csharp",
-        grammar: "c_sharp",
-        extract: extractCSharp,
-        extractDirectives: extractDirectivesCSharp,
-        extractImports: extractImportsCSharp,
+        language: "csharp", grammar: "c_sharp",
+        extract: extractCSharp, extractDirectives: extractDirectivesCSharp, extractImports: extractImportsCSharp,
     },
+    ".c": { language: "c", grammar: "c", extract: extractC, extractImports: extractImportsC },
+    ".h": { language: "c", grammar: "c", extract: extractC, extractImports: extractImportsC },
+    ".cpp": { language: "cpp", grammar: "cpp", extract: extractCpp, extractImports: extractImportsCpp },
+    ".cxx": { language: "cpp", grammar: "cpp", extract: extractCpp, extractImports: extractImportsCpp },
+    ".cc": { language: "cpp", grammar: "cpp", extract: extractCpp, extractImports: extractImportsCpp },
+    ".hpp": { language: "cpp", grammar: "cpp", extract: extractCpp, extractImports: extractImportsCpp },
+    ".hxx": { language: "cpp", grammar: "cpp", extract: extractCpp, extractImports: extractImportsCpp },
+    ".hh": { language: "cpp", grammar: "cpp", extract: extractCpp, extractImports: extractImportsCpp },
+    ".kt": {
+        language: "kotlin", grammar: "kotlin",
+        extract: extractKotlin, extractDirectives: extractDirectivesKotlin, extractImports: extractImportsKotlin,
+    },
+    ".kts": {
+        language: "kotlin", grammar: "kotlin",
+        extract: extractKotlin, extractDirectives: extractDirectivesKotlin, extractImports: extractImportsKotlin,
+    },
+    ".swift": { language: "swift", grammar: "swift", extract: extractSwift, extractImports: extractImportsSwift },
 };
 export function detectLanguage(filePath) {
     return BY_EXT[path.extname(filePath).toLowerCase()] ?? null;

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.7.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",