universal-ast-mapper 0.5.2

package/dist/extractors/common.js

@@ -0,0 +1,54 @@
+export function lineRange(node) {
+    return { startLine: node.startPosition.row + 1, endLine: node.endPosition.row + 1 };
+}
+/** True if the identifier begins with an uppercase letter (Go export rule). */
+export function startsUpper(name) {
+    const c = name[0];
+    return !!c && c !== c.toLowerCase() && c === c.toUpperCase();
+}
+/** Python convention: a single leading underscore (but not dunder) means private. */
+export function pythonVisibility(name) {
+    if (name.startsWith("__") && name.endsWith("__"))
+        return "public"; // dunder
+    return name.startsWith("_") ? "private" : "public";
+}
+export function makeSymbol(init) {
+    const sym = {
+        name: init.name,
+        kind: init.kind,
+        visibility: init.visibility ?? "public",
+        range: lineRange(init.node),
+        children: init.children ?? [],
+    };
+    if (init.rawKind !== undefined)
+        sym.rawKind = init.rawKind;
+    if (init.signature !== undefined)
+        sym.signature = init.signature;
+    if (init.exported !== undefined)
+        sym.exported = init.exported;
+    if (init.doc !== undefined)
+        sym.doc = init.doc;
+    return sym;
+}
+/** Count a symbol tree, including nested children. */
+export function countSymbols(symbols) {
+    let n = 0;
+    for (const s of symbols)
+        n += 1 + countSymbols(s.children);
+    return n;
+}
+/** Strip signature/doc/rawKind for the compact "outline" detail level. */
+export function toOutline(symbols) {
+    return symbols.map((s) => {
+        const out = {
+            name: s.name,
+            kind: s.kind,
+            visibility: s.visibility,
+            range: s.range,
+            children: toOutline(s.children),
+        };
+        if (s.exported !== undefined)
+            out.exported = s.exported;
+        return out;
+    });
+}

package/dist/extractors/go.js

@@ -0,0 +1,212 @@
+import { namedChildren, nameOf, headerSignature, leadingComment } from "../parser.js";
+import { makeSymbol, startsUpper } from "./common.js";
+// ─── Import extraction ────────────────────────────────────────────────────────
+export function extractImportsGo(root, _source) {
+    const imports = [];
+    for (const child of namedChildren(root)) {
+        if (child.type === "import_declaration")
+            parseGoImportDecl(child, imports);
+    }
+    return imports;
+}
+function parseGoImportDecl(node, out) {
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const c = node.namedChild(i);
+        if (!c)
+            continue;
+        if (c.type === "import_spec")
+            parseGoImportSpec(c, out);
+        else if (c.type === "import_spec_list") {
+            for (let j = 0; j < c.namedChildCount; j++) {
+                const spec = c.namedChild(j);
+                if (spec && spec.type === "import_spec")
+                    parseGoImportSpec(spec, out);
+            }
+        }
+    }
+}
+function parseGoImportSpec(spec, out) {
+    const pathNode = spec.childForFieldName("path");
+    const nameNode = spec.childForFieldName("name");
+    if (!pathNode)
+        return;
+    const from = pathNode.text.replace(/^['"`]|['"`]$/g, "");
+    const pkgName = from.split("/").pop() ?? from;
+    if (!nameNode) {
+        out.push({ symbol: pkgName, from });
+    }
+    else if (nameNode.text === ".") {
+        out.push({ symbol: ".", from, isNamespaceImport: true });
+    }
+    else if (nameNode.text === "_") {
+        out.push({ symbol: "_", from, isSideEffect: true });
+    }
+    else {
+        out.push({ symbol: pkgName, from, alias: nameNode.text });
+    }
+}
+// ─── Symbol extraction ────────────────────────────────────────────────────────
+export function extractGo(root, _source) {
+    const out = [];
+    for (const n of namedChildren(root)) {
+        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 "function_declaration": {
+            const name = nameOf(node) ?? "(func)";
+            return makeSymbol({
+                name,
+                kind: "function",
+                node,
+                rawKind: node.type,
+                signature: headerSignature(node, node.childForFieldName("body")),
+                visibility: startsUpper(name) ? "public" : "private",
+                exported: startsUpper(name),
+                doc: leadingComment(node),
+            });
+        }
+        case "method_declaration": {
+            const name = nameOf(node) ?? "(method)";
+            return makeSymbol({
+                name,
+                kind: "method",
+                node,
+                rawKind: node.type,
+                signature: headerSignature(node, node.childForFieldName("body")),
+                visibility: startsUpper(name) ? "public" : "private",
+                exported: startsUpper(name),
+                doc: leadingComment(node),
+            });
+        }
+        case "type_declaration": {
+            const out = [];
+            for (const spec of namedChildren(node)) {
+                if (spec.type === "type_spec" || spec.type === "type_alias") {
+                    const sym = fromTypeSpec(spec, node);
+                    if (sym)
+                        out.push(sym);
+                }
+            }
+            return out;
+        }
+        case "const_declaration":
+            return fromValueSpecs(node, "const");
+        case "var_declaration":
+            return fromValueSpecs(node, "var");
+        default:
+            return null;
+    }
+}
+function fromTypeSpec(spec, declNode) {
+    const name = nameOf(spec);
+    if (!name)
+        return null;
+    const typeNode = spec.childForFieldName("type");
+    const exported = startsUpper(name);
+    const visibility = exported ? "public" : "private";
+    const doc = leadingComment(declNode);
+    if (typeNode && typeNode.type === "struct_type") {
+        return makeSymbol({
+            name,
+            kind: "struct",
+            node: spec,
+            rawKind: spec.type,
+            visibility,
+            exported,
+            doc,
+            children: structFields(typeNode),
+        });
+    }
+    if (typeNode && typeNode.type === "interface_type") {
+        return makeSymbol({
+            name,
+            kind: "interface",
+            node: spec,
+            rawKind: spec.type,
+            visibility,
+            exported,
+            doc,
+            children: interfaceMethods(typeNode),
+        });
+    }
+    return makeSymbol({
+        name,
+        kind: "type",
+        node: spec,
+        rawKind: spec.type,
+        signature: headerSignature(spec, null),
+        visibility,
+        exported,
+        doc,
+    });
+}
+function structFields(structType) {
+    const list = namedChildren(structType).find((c) => c.type === "field_declaration_list");
+    if (!list)
+        return [];
+    const out = [];
+    for (const field of namedChildren(list)) {
+        if (field.type !== "field_declaration")
+            continue;
+        const name = nameOf(field);
+        if (!name)
+            continue; // skip embedded fields
+        out.push(makeSymbol({
+            name,
+            kind: "field",
+            node: field,
+            rawKind: field.type,
+            signature: field.text.replace(/\s+/g, " ").trim(),
+            visibility: startsUpper(name) ? "public" : "private",
+            exported: startsUpper(name),
+        }));
+    }
+    return out;
+}
+function interfaceMethods(interfaceType) {
+    const out = [];
+    for (const m of namedChildren(interfaceType)) {
+        if (m.type !== "method_spec" && m.type !== "method_elem")
+            continue;
+        const name = nameOf(m);
+        if (!name)
+            continue;
+        out.push(makeSymbol({
+            name,
+            kind: "method",
+            node: m,
+            rawKind: m.type,
+            signature: headerSignature(m, null),
+            visibility: startsUpper(name) ? "public" : "private",
+            exported: startsUpper(name),
+        }));
+    }
+    return out;
+}
+function fromValueSpecs(node, kind) {
+    const out = [];
+    for (const spec of namedChildren(node)) {
+        if (spec.type !== "const_spec" && spec.type !== "var_spec")
+            continue;
+        const name = nameOf(spec);
+        if (!name)
+            continue;
+        out.push(makeSymbol({
+            name,
+            kind,
+            node: spec,
+            rawKind: spec.type,
+            signature: spec.text.replace(/\s+/g, " ").trim(),
+            visibility: startsUpper(name) ? "public" : "private",
+            exported: startsUpper(name),
+        }));
+    }
+    return out;
+}

package/dist/extractors/python.js

@@ -0,0 +1,142 @@
+import { namedChildren, nameOf, headerSignature } from "../parser.js";
+import { makeSymbol, pythonVisibility } from "./common.js";
+export function extractPython(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) {
+    if (node.type === "decorated_definition") {
+        const inner = innerDefinition(node);
+        return inner ? handle(inner, insideClass) : null;
+    }
+    if (node.type === "class_definition") {
+        const name = nameOf(node) ?? "(class)";
+        const body = node.childForFieldName("body");
+        const children = body ? collect(namedChildren(body), true) : [];
+        return makeSymbol({
+            name,
+            kind: "class",
+            node,
+            rawKind: node.type,
+            visibility: pythonVisibility(name),
+            exported: pythonVisibility(name) === "public",
+            doc: body ? docstring(body) : null,
+            children,
+        });
+    }
+    if (node.type === "function_definition") {
+        const name = nameOf(node) ?? "(function)";
+        const body = node.childForFieldName("body");
+        return makeSymbol({
+            name,
+            kind: insideClass ? "method" : "function",
+            node,
+            rawKind: node.type,
+            signature: headerSignature(node, body),
+            visibility: pythonVisibility(name),
+            exported: pythonVisibility(name) === "public",
+            doc: body ? docstring(body) : null,
+        });
+    }
+    return null;
+}
+function innerDefinition(decorated) {
+    const byField = decorated.childForFieldName("definition");
+    if (byField)
+        return byField;
+    for (const c of namedChildren(decorated)) {
+        if (c.type === "function_definition" || c.type === "class_definition")
+            return c;
+    }
+    return null;
+}
+// ─── Import extraction ────────────────────────────────────────────────────────
+export function extractImportsPython(root, _source) {
+    const imports = [];
+    for (const child of namedChildren(root)) {
+        if (child.type === "import_statement")
+            parseSimpleImport(child, imports);
+        else if (child.type === "import_from_statement")
+            parseFromImport(child, imports);
+    }
+    return imports;
+}
+function parseSimpleImport(node, out) {
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const c = node.namedChild(i);
+        if (!c)
+            continue;
+        if (c.type === "dotted_name" || c.type === "identifier") {
+            out.push({ symbol: c.text, from: c.text });
+        }
+        else if (c.type === "aliased_import") {
+            const nameNode = c.childForFieldName("name");
+            const aliasNode = c.childForFieldName("alias");
+            if (nameNode) {
+                const imp = { symbol: nameNode.text, from: nameNode.text };
+                if (aliasNode)
+                    imp.alias = aliasNode.text;
+                out.push(imp);
+            }
+        }
+    }
+}
+/**
+ * Convert Python import path to a JS-style relative path.
+ * ".models" → "./models", "..utils" → "../utils", "os" → "os" (external).
+ */
+function pythonFromPath(raw) {
+    const m = raw.match(/^(\.+)(.*)/);
+    if (!m)
+        return raw; // absolute/external import
+    const dotCount = m[1].length;
+    const rest = m[2]; // module name after the dots, e.g. "models" or ""
+    const upDirs = dotCount === 1 ? "." : Array(dotCount - 1).fill("..").join("/");
+    return rest ? `${upDirs}/${rest.replace(/\./g, "/")}` : upDirs;
+}
+function parseFromImport(node, out) {
+    const moduleNode = node.childForFieldName("module_name");
+    const from = moduleNode ? pythonFromPath(moduleNode.text) : ".";
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const c = node.namedChild(i);
+        if (!c || c === moduleNode)
+            continue;
+        if (c.type === "wildcard_import") {
+            out.push({ symbol: "*", from, isNamespaceImport: true });
+        }
+        else if (c.type === "relative_import" || c.type === "dotted_name") {
+            // skip — these are part of the module path, not the imported names
+        }
+        else if (c.type === "identifier") {
+            out.push({ symbol: c.text, from });
+        }
+        else if (c.type === "aliased_import") {
+            const nameNode = c.childForFieldName("name");
+            const aliasNode = c.childForFieldName("alias");
+            if (nameNode) {
+                const imp = { symbol: nameNode.text, from };
+                if (aliasNode)
+                    imp.alias = aliasNode.text;
+                out.push(imp);
+            }
+        }
+    }
+}
+/** Extract a leading triple-quoted docstring from a `block`. */
+function docstring(body) {
+    const first = body.namedChild(0);
+    if (!first || first.type !== "expression_statement")
+        return null;
+    const str = first.namedChild(0);
+    if (!str || str.type !== "string")
+        return null;
+    return str.text.replace(/^[rbuRBU]*("""|'''|"|')/, "").replace(/("""|'''|"|')$/, "").trim().slice(0, 500);
+}