diffninja 0.1.0

package/dist/languages/elixir.js

@@ -0,0 +1,331 @@
+import { heuristicCallSyntax, parameterText, textOnlyParams, } from "./call-syntax.js";
+import { childByType, collapseWs, locFromNode, namedChildren, } from "./types.js";
+function isDefKw(name) {
+    return name === "def" || name === "defp" || name === "defmacro" || name === "defmacrop";
+}
+function isPrivateDef(name) {
+    return name === "defp" || name === "defmacrop";
+}
+function getParamsLabel(args) {
+    if (!args)
+        return "()";
+    // def foo(a, b) → arguments node under the name call
+    const names = [];
+    for (const c of namedChildren(args)) {
+        if (c.type === "identifier")
+            names.push(c.text);
+        else if (c.type === "keywords")
+            continue;
+        else
+            names.push("_");
+    }
+    return names.length === 0 ? "()" : `(${names.join(", ")})`;
+}
+/** Extract def name + params from `def`/`defp` call arguments. */
+function defNameAndParams(args) {
+    if (!args)
+        return null;
+    const kids = namedChildren(args);
+    const head = kids[0] ?? null;
+    if (!head)
+        return null;
+    if (head.type === "identifier") {
+        return { name: head.text, params: null };
+    }
+    if (head.type === "call") {
+        const id = childByType(head, "identifier");
+        if (!id)
+            return null;
+        return { name: id.text, params: childByType(head, "arguments") };
+    }
+    // def foo(%{}), do: ... — pattern head
+    if (head.type === "binary_operator") {
+        const left = head.namedChild(0);
+        if (left?.type === "identifier")
+            return { name: left.text, params: null };
+        if (left?.type === "call") {
+            const id = childByType(left, "identifier");
+            if (id)
+                return { name: id.text, params: childByType(left, "arguments") };
+        }
+    }
+    return null;
+}
+function calleeKey(node, moduleName, hasExplicitArgs) {
+    if (node.type === "identifier") {
+        // Bare call inside a module → Module.fun (local call)
+        if (moduleName)
+            return `${moduleName}.${node.text}`;
+        return node.text;
+    }
+    if (node.type === "dot") {
+        const left = node.namedChild(0);
+        const right = node.namedChild(1);
+        if (!right)
+            return null;
+        const prop = right.text;
+        if (!left)
+            return prop;
+        if (left.type === "alias") {
+            // Foo.Bar.baz → use full alias text
+            return `${left.text}.${prop}`;
+        }
+        if (left.type === "identifier") {
+            // options.session_id with no args is field-ish remote call noise — skip
+            if (!hasExplicitArgs && left.text[0] && left.text[0] === left.text[0].toLowerCase()) {
+                return null;
+            }
+            return `${left.text}.${prop}`;
+        }
+        // get_services().boot() — left is call; keep receiver.prop when possible
+        if (left.type === "call") {
+            return prop;
+        }
+        if (moduleName)
+            return `${moduleName}.${prop}`;
+        return prop;
+    }
+    // access_call opts[:ok] — not a callable we track
+    if (node.type === "access_call")
+        return null;
+    return null;
+}
+function bodyOfDef(call) {
+    const doBlock = childByType(call, "do_block");
+    if (doBlock)
+        return doBlock;
+    // def foo, do: expr  → keywords pair
+    const args = childByType(call, "arguments");
+    const keywords = args ? childByType(args, "keywords") : null;
+    if (keywords) {
+        const pair = childByType(keywords, "pair");
+        if (pair) {
+            // keyword + value; value is last named child
+            const kids = namedChildren(pair);
+            return kids[kids.length - 1] ?? null;
+        }
+    }
+    return null;
+}
+function collectBody(file, body, moduleName) {
+    if (!body)
+        return [];
+    return collectStatements(file, namedChildren(body), moduleName);
+}
+function collectStatements(file, statements, moduleName) {
+    const steps = [];
+    const seen = new Set();
+    const addCall = (key, node) => {
+        const mark = `${key}:${node.startIndex}`;
+        if (seen.has(mark))
+            return;
+        seen.add(mark);
+        const step = { type: "call", key, ...locFromNode(file, node) };
+        step.syntax = heuristicCallSyntax(node, key);
+        steps.push(step);
+    };
+    const walk = (node) => {
+        // Nested defs / anonymous fn — do not attribute to outer
+        if (node.type === "anonymous_function")
+            return;
+        if (node.type === "call") {
+            const head = childByType(node, "identifier");
+            if (head && (isDefKw(head.text) || head.text === "fn" || head.text === "defmodule")) {
+                return;
+            }
+            if (head && head.text === "if") {
+                const args = childByType(node, "arguments");
+                const cond = args?.namedChild(0) ?? null;
+                const condText = cond ? collapseWs(cond.text) : "";
+                const doBlock = childByType(node, "do_block");
+                const thenKids = doBlock
+                    ? namedChildren(doBlock).filter((c) => c.type !== "else_block")
+                    : [];
+                const elseBlock = doBlock ? childByType(doBlock, "else_block") : null;
+                steps.push({
+                    type: "branch",
+                    key: condText ? `if:${condText}` : "if",
+                    label: condText ? `if ${condText}` : "if",
+                    ...locFromNode(file, cond ?? node),
+                    children: collectStatements(file, thenKids, moduleName),
+                });
+                if (elseBlock) {
+                    steps.push({
+                        type: "branch",
+                        key: "else",
+                        label: "else",
+                        ...locFromNode(file, elseBlock),
+                        children: collectBody(file, elseBlock, moduleName),
+                    });
+                }
+                // cond may contain calls — walk it
+                if (cond)
+                    walk(cond);
+                return;
+            }
+            if (head && head.text === "case") {
+                const doBlock = childByType(node, "do_block");
+                for (const clause of doBlock ? namedChildren(doBlock) : []) {
+                    if (clause.type !== "stab_clause")
+                        continue;
+                    const pattern = childByType(clause, "arguments");
+                    const text = pattern ? collapseWs(pattern.text) : "";
+                    const body = childByType(clause, "body");
+                    steps.push({
+                        type: "branch",
+                        key: text ? `case:${text}` : "case",
+                        label: text ? `case ${text}` : "case",
+                        ...locFromNode(file, pattern ?? clause),
+                        children: body ? collectBody(file, body, moduleName) : [],
+                    });
+                }
+                return;
+            }
+            if (head && head.text === "cond") {
+                const doBlock = childByType(node, "do_block");
+                for (const clause of doBlock ? namedChildren(doBlock) : []) {
+                    if (clause.type !== "stab_clause")
+                        continue;
+                    const pattern = childByType(clause, "arguments");
+                    const text = pattern ? collapseWs(pattern.text) : "";
+                    const body = childByType(clause, "body");
+                    steps.push({
+                        type: "branch",
+                        key: text ? `cond:${text}` : "cond",
+                        label: text ? `cond ${text}` : "cond",
+                        ...locFromNode(file, pattern ?? clause),
+                        children: body ? collectBody(file, body, moduleName) : [],
+                    });
+                }
+                return;
+            }
+            if (head && head.text === "try") {
+                const doBlock = childByType(node, "do_block");
+                const tryKids = doBlock
+                    ? namedChildren(doBlock).filter((c) => c.type !== "rescue_block" &&
+                        c.type !== "catch_block" &&
+                        c.type !== "after_block" &&
+                        c.type !== "else_block")
+                    : [];
+                steps.push({
+                    type: "branch",
+                    key: "try",
+                    label: "try",
+                    ...locFromNode(file, node),
+                    children: collectStatements(file, tryKids, moduleName),
+                });
+                const rescue = doBlock ? childByType(doBlock, "rescue_block") : null;
+                if (rescue) {
+                    for (const clause of namedChildren(rescue)) {
+                        if (clause.type !== "stab_clause")
+                            continue;
+                        const pattern = childByType(clause, "arguments");
+                        const text = pattern ? collapseWs(pattern.text) : "";
+                        const body = childByType(clause, "body");
+                        steps.push({
+                            type: "branch",
+                            key: text ? `rescue:${text}` : "rescue",
+                            label: text ? `rescue ${text}` : "rescue",
+                            ...locFromNode(file, pattern ?? clause),
+                            children: body ? collectBody(file, body, moduleName) : [],
+                        });
+                    }
+                }
+                const after = doBlock ? childByType(doBlock, "after_block") : null;
+                if (after) {
+                    steps.push({
+                        type: "branch",
+                        key: "after",
+                        label: "after",
+                        ...locFromNode(file, after),
+                        children: collectBody(file, after, moduleName),
+                    });
+                }
+                return;
+            }
+            // Regular call — callee is first named child (identifier or dot)
+            const callee = node.namedChild(0);
+            const args = childByType(node, "arguments");
+            // Explicit args node present (even empty `()`) vs bare `foo.bar`
+            const hasExplicitArgs = args !== null;
+            if (callee && callee.type !== "do_block") {
+                const key = calleeKey(callee, moduleName, hasExplicitArgs);
+                if (key)
+                    addCall(key, node);
+            }
+            // Walk args for nested calls, but skip field-ish dots without further calls
+            if (args)
+                walk(args);
+            const doBlock = childByType(node, "do_block");
+            if (doBlock)
+                walk(doBlock);
+            return;
+        }
+        for (const child of namedChildren(node))
+            walk(child);
+    };
+    for (const stmt of statements)
+        walk(stmt);
+    return steps;
+}
+function handleDef(file, call, moduleName, functions) {
+    const kw = childByType(call, "identifier")?.text ?? "def";
+    const args = childByType(call, "arguments");
+    const parsed = defNameAndParams(args);
+    if (!parsed)
+        return;
+    const { name, params } = parsed;
+    const body = bodyOfDef(call);
+    const key = moduleName ? `${moduleName}.${name}` : name;
+    const exported = !isPrivateDef(kw);
+    functions.push({
+        key,
+        label: `${key}${getParamsLabel(params)}`,
+        // Elixir uses `arguments` for a declared list as well as a call's.
+        params: textOnlyParams(parameterText(params)),
+        file,
+        steps: collectBody(file, body, moduleName),
+        exported,
+        start: call.startIndex,
+        end: call.endIndex,
+    });
+}
+function handleDefmodule(file, call, functions) {
+    const args = childByType(call, "arguments");
+    const alias = args ? childByType(args, "alias") : null;
+    const moduleName = alias?.text ?? null;
+    if (!moduleName)
+        return;
+    const body = childByType(call, "do_block");
+    if (!body)
+        return;
+    for (const stmt of namedChildren(body)) {
+        if (stmt.type !== "call")
+            continue;
+        const kw = childByType(stmt, "identifier")?.text;
+        if (kw && isDefKw(kw)) {
+            handleDef(file, stmt, moduleName, functions);
+        }
+    }
+}
+function extractFromTree(file, _source, tree) {
+    const functions = [];
+    for (const stmt of namedChildren(tree.rootNode)) {
+        if (stmt.type !== "call")
+            continue;
+        const kw = childByType(stmt, "identifier")?.text;
+        if (kw === "defmodule") {
+            handleDefmodule(file, stmt, functions);
+        }
+        else if (kw && isDefKw(kw)) {
+            handleDef(file, stmt, null, functions);
+        }
+    }
+    return functions;
+}
+export const elixirExtractor = {
+    id: "elixir",
+    extensions: [".ex", ".exs"],
+    grammarPackage: "tree-sitter-elixir",
+    extract: extractFromTree,
+};

package/dist/languages/go.d.ts

@@ -0,0 +1,2 @@
+import { type LanguageExtractor } from "./types.js";
+export declare const goExtractor: LanguageExtractor;

package/dist/languages/go.js

@@ -0,0 +1,299 @@
+import { heuristicCallSyntax } from "./call-syntax.js";
+import { childByType, declaredParamsOf, collapseWs, locFromNode, namedChildren, sameNode, } from "./types.js";
+function isExported(name) {
+    const ch = name[0];
+    return ch !== undefined && ch === ch.toUpperCase() && ch !== ch.toLowerCase();
+}
+function getParamsLabel(params) {
+    if (!params || params.type !== "parameter_list")
+        return "()";
+    const names = [];
+    for (const p of namedChildren(params)) {
+        if (p.type !== "parameter_declaration")
+            continue;
+        const ids = namedChildren(p).filter((c) => c.type === "identifier");
+        if (ids.length === 0)
+            names.push("_");
+        else
+            for (const id of ids)
+                names.push(id.text);
+    }
+    return names.length === 0 ? "()" : `(${names.join(", ")})`;
+}
+function calleeKey(node, receiverType, receiverName) {
+    if (node.type === "identifier") {
+        // NewThing() → new Thing (constructor alias)
+        if (node.text.startsWith("New") && node.text.length > 3) {
+            const typeName = node.text.slice(3);
+            if (isExported(typeName))
+                return `new ${typeName}`;
+        }
+        return node.text;
+    }
+    if (node.type === "selector_expression") {
+        const object = node.namedChild(0);
+        const field = childByType(node, "field_identifier");
+        if (!object || !field)
+            return null;
+        const prop = field.text;
+        if (object.type === "identifier") {
+            const objName = object.text;
+            if (receiverType && receiverName && objName === receiverName) {
+                return `${receiverType}.${prop}`;
+            }
+            return `${objName}.${prop}`;
+        }
+        return `${collapseWs(object.text)}.${prop}`;
+    }
+    return null;
+}
+function statementsOf(node) {
+    if (node.type === "block") {
+        const list = childByType(node, "statement_list");
+        return list ? namedChildren(list) : namedChildren(node);
+    }
+    if (node.type === "statement_list")
+        return namedChildren(node);
+    return [node];
+}
+function collectIf(file, node, receiverType, receiverName, steps, asElseIf = false) {
+    const kids = namedChildren(node);
+    const consequent = kids.find((c) => c.type === "block") ?? null;
+    const alt = kids.find((c) => !sameNode(c, consequent) && (c.type === "block" || c.type === "if_statement")) ??
+        null;
+    const before = consequent
+        ? kids.slice(0, kids.indexOf(consequent))
+        : kids;
+    const condNode = before[before.length - 1] ?? null;
+    const condText = condNode ? collapseWs(condNode.text) : "";
+    const kind = asElseIf ? "else-if" : "if";
+    const labelKind = asElseIf ? "else if" : "if";
+    steps.push({
+        type: "branch",
+        key: condText ? `${kind}:${condText}` : kind,
+        label: condText ? `${labelKind} ${condText}` : labelKind,
+        ...locFromNode(file, condNode ?? node),
+        children: consequent
+            ? collectStatements(file, statementsOf(consequent), receiverType, receiverName)
+            : [],
+    });
+    if (!alt)
+        return;
+    if (alt.type === "if_statement") {
+        collectIf(file, alt, receiverType, receiverName, steps, true);
+    }
+    else {
+        steps.push({
+            type: "branch",
+            key: "else",
+            label: "else",
+            ...locFromNode(file, alt),
+            children: collectStatements(file, statementsOf(alt), receiverType, receiverName),
+        });
+    }
+}
+function collectStatements(file, statements, receiverType, receiverName) {
+    const steps = [];
+    const seen = new Set();
+    const addCall = (key, node, children) => {
+        const mark = `${key}:${node.startIndex}`;
+        if (seen.has(mark))
+            return;
+        seen.add(mark);
+        const step = {
+            type: "call",
+            key,
+            ...locFromNode(file, node),
+            children,
+        };
+        step.syntax = heuristicCallSyntax(node, key);
+        steps.push(step);
+    };
+    const walk = (node) => {
+        if (node.type === "function_declaration" ||
+            node.type === "method_declaration" ||
+            node.type === "func_literal") {
+            return;
+        }
+        if (node.type === "if_statement") {
+            collectIf(file, node, receiverType, receiverName, steps, false);
+            return;
+        }
+        if (node.type === "defer_statement") {
+            steps.push({
+                type: "branch",
+                key: "defer",
+                label: "defer",
+                ...locFromNode(file, node),
+                children: collectStatements(file, namedChildren(node), receiverType, receiverName),
+            });
+            return;
+        }
+        if (node.type === "expression_switch_statement" ||
+            node.type === "type_switch_statement") {
+            const kids = namedChildren(node);
+            const subject = kids.find((c) => c.type !== "expression_case" &&
+                c.type !== "type_case" &&
+                c.type !== "default_case") ?? null;
+            const subjectText = subject ? collapseWs(subject.text) : "";
+            for (const clause of kids) {
+                if (clause.type === "expression_case" || clause.type === "type_case") {
+                    const expr = childByType(clause, "expression_list") ??
+                        childByType(clause, "type_list") ??
+                        namedChildren(clause).find((c) => c.type !== "statement_list") ??
+                        null;
+                    const text = expr ? collapseWs(expr.text) : "";
+                    const list = childByType(clause, "statement_list");
+                    steps.push({
+                        type: "branch",
+                        key: text ? `case:${text}` : "case",
+                        label: text
+                            ? `case ${text}`
+                            : subjectText
+                                ? `case ${subjectText}`
+                                : "case",
+                        ...locFromNode(file, expr ?? clause),
+                        children: list
+                            ? collectStatements(file, namedChildren(list), receiverType, receiverName)
+                            : [],
+                    });
+                }
+                if (clause.type === "default_case") {
+                    const list = childByType(clause, "statement_list");
+                    steps.push({
+                        type: "branch",
+                        key: "default",
+                        label: "default",
+                        ...locFromNode(file, clause),
+                        children: list
+                            ? collectStatements(file, namedChildren(list), receiverType, receiverName)
+                            : [],
+                    });
+                }
+            }
+            return;
+        }
+        if (node.type === "call_expression") {
+            const callee = node.namedChild(0);
+            const args = childByType(node, "argument_list");
+            const inlineChildren = args
+                ? namedChildren(args).flatMap((arg) => {
+                    if (arg.type !== "func_literal")
+                        return [];
+                    const body = childByType(arg, "block");
+                    return body
+                        ? collectStatements(file, statementsOf(body), receiverType, receiverName)
+                        : [];
+                })
+                : [];
+            if (callee && callee.type !== "func_literal") {
+                const key = calleeKey(callee, receiverType, receiverName);
+                if (key)
+                    addCall(key, node, inlineChildren);
+            }
+            // Do not walk into func_literal callees/bodies
+            for (const child of namedChildren(node)) {
+                if (child.type === "func_literal")
+                    continue;
+                if (sameNode(child, callee))
+                    continue;
+                walk(child);
+            }
+            return;
+        }
+        for (const child of namedChildren(node))
+            walk(child);
+    };
+    for (const stmt of statements)
+        walk(stmt);
+    return steps;
+}
+function receiverTypeName(method) {
+    const recv = method.namedChild(0);
+    if (!recv || recv.type !== "parameter_list")
+        return null;
+    const decl = childByType(recv, "parameter_declaration");
+    if (!decl)
+        return null;
+    const pointer = childByType(decl, "pointer_type");
+    const typeId = childByType(pointer ?? decl, "type_identifier") ??
+        childByType(decl, "type_identifier");
+    return typeId?.text ?? null;
+}
+function receiverVariableName(method) {
+    const recv = method.namedChild(0);
+    if (!recv || recv.type !== "parameter_list")
+        return null;
+    const decl = childByType(recv, "parameter_declaration");
+    return decl ? childByType(decl, "identifier")?.text ?? null : null;
+}
+function handleFunction(file, node, functions) {
+    const name = childByType(node, "identifier")?.text ?? null;
+    if (!name)
+        return;
+    const params = namedChildren(node).find((c) => c.type === "parameter_list") ?? null;
+    const body = childByType(node, "block");
+    const info = {
+        key: name,
+        label: `${name}${getParamsLabel(params)}`,
+        params: declaredParamsOf(node),
+        file,
+        steps: body ? collectStatements(file, statementsOf(body), null, null) : [],
+        exported: isExported(name),
+        start: node.startIndex,
+        end: node.endIndex,
+    };
+    functions.push(info);
+    // NewThing → constructor alias `new Thing`
+    if (name.startsWith("New") && name.length > 3) {
+        const typeName = name.slice(3);
+        if (isExported(typeName)) {
+            functions.push({
+                ...info,
+                key: `new ${typeName}`,
+                label: `${typeName}()`,
+            });
+        }
+    }
+}
+function handleMethod(file, node, functions) {
+    const typeName = receiverTypeName(node);
+    const receiverName = receiverVariableName(node);
+    const name = childByType(node, "field_identifier")?.text ?? null;
+    if (!typeName || !name)
+        return;
+    const paramLists = namedChildren(node).filter((c) => c.type === "parameter_list");
+    const params = paramLists[1] ?? paramLists[0] ?? null;
+    const body = childByType(node, "block");
+    const key = `${typeName}.${name}`;
+    functions.push({
+        key,
+        label: `${key}${getParamsLabel(params)}`,
+        params: declaredParamsOf(node),
+        file,
+        steps: body
+            ? collectStatements(file, statementsOf(body), typeName, receiverName)
+            : [],
+        exported: isExported(name),
+        start: node.startIndex,
+        end: node.endIndex,
+    });
+}
+function extractFromTree(file, _source, tree) {
+    const functions = [];
+    for (const stmt of namedChildren(tree.rootNode)) {
+        if (stmt.type === "function_declaration") {
+            handleFunction(file, stmt, functions);
+        }
+        else if (stmt.type === "method_declaration") {
+            handleMethod(file, stmt, functions);
+        }
+    }
+    return functions;
+}
+export const goExtractor = {
+    id: "go",
+    extensions: [".go"],
+    grammarPackage: "tree-sitter-go",
+    extract: extractFromTree,
+};

package/dist/languages/grammars.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Loaded tree-sitter grammar package surface.
+ * Named exports (`typescript`, `tsx`, …) are looked up by `resolveLanguage`.
+ */
+export type GrammarModule = {
+    language?: GrammarModule;
+    typescript?: GrammarModule;
+    tsx?: GrammarModule;
+    [exportName: string]: GrammarModule | undefined;
+};
+/** Runtime grammar handle passed to `parser.setLanguage`. */
+export type GrammarLanguage = GrammarModule;
+/** On-disk cache of npm-installed tree-sitter grammar packages. */
+export declare function grammarCacheDir(): string;
+/**
+ * The cache's own package.json, which also allows the grammar's install
+ * script: npm 12 blocks dependency install scripts unless `allowScripts`
+ * names them, and rejects `--allow-scripts` in a project install like this
+ * one. Earlier npm ignores the field. A cache written before this keeps its
+ * other fields and gains the entry.
+ */
+export declare function ensureCachePackageJson(cacheDir: string, npmPackage: string): void;
+/**
+ * Absolute path to one of npm's JS entry points (`npm-cli.js`, `npx-cli.js`),
+ * or undefined when npm is not installed beside Node.
+ */
+export declare function npmCliPath(cli: string, directories?: readonly string[]): string | undefined;
+/**
+ * On Windows, npm.cmd is a shell script, not an executable. Run npm's JS entry
+ * with Node instead: cache paths (including spaces and percent signs) remain
+ * literal argv values rather than being interpreted by cmd.exe.
+ */
+export declare function npmSpawnSpec(args: string[], platform?: NodeJS.Platform): {
+    file: string;
+    args: string[];
+};
+/**
+ * Path of this platform's prebuild when the file exists but targets another
+ * CPU (e.g. x86-64 bytes shipped as linux-arm64). Null when the prebuild is
+ * absent, unreadable, or correct: only a confirmed mismatch is reported.
+ * Exported for tests and diagnostics.
+ */
+export declare function mislabeledPrebuild(packageRoot: string): string | null;
+/**
+ * Install an npm grammar package into the shared cache if missing, then require it.
+ * Reuses the cache across CLI invocations.
+ */
+export declare function loadGrammarPackage(npmPackage: string): GrammarModule;
+/** Resolve the value to pass to parser.setLanguage. */
+export declare function resolveLanguage(mod: GrammarModule, exportName?: string): GrammarLanguage;