universal-ast-mapper 0.7.0 → 0.8.0

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,7 @@ src/
 
 | Version | What changed |
 |---------|--------------|
+| **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/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/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/package.json

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