diffninja 0.1.0

package/dist/languages/bash.js

@@ -0,0 +1,208 @@
+import { heuristicCallSyntax } from "./call-syntax.js";
+import { childByType, collapseWs, locFromNode, namedChildren, sameNode, } from "./types.js";
+const SKIP_COMMANDS = new Set([
+    ":",
+    "true",
+    "false",
+    "echo",
+    "printf",
+    "local",
+    "export",
+    "readonly",
+    "return",
+    "exit",
+    "shift",
+    "set",
+    "unset",
+    "cd",
+    "pwd",
+    "test",
+    "[",
+    "[[",
+    "source",
+    ".",
+    "eval",
+    "exec",
+    "command",
+    "builtin",
+    "type",
+    "hash",
+    "wait",
+    "trap",
+    "read",
+    "mapfile",
+    "declare",
+    "typeset",
+]);
+function commandName(cmd) {
+    const nameNode = childByType(cmd, "command_name") ?? namedChildren(cmd)[0] ?? null;
+    if (!nameNode)
+        return null;
+    const word = nameNode.type === "word"
+        ? nameNode
+        : childByType(nameNode, "word") ?? nameNode.namedChild(0);
+    const text = (word ?? nameNode).text;
+    if (!text || SKIP_COMMANDS.has(text))
+        return null;
+    // Dynamic: "$cmd" / "${cmd}" / $(...) as name
+    if (text.startsWith("$") || nameNode.type === "command_substitution") {
+        return null;
+    }
+    return text;
+}
+function collectStatements(file, statements) {
+    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 function bodies are not attributed to the outer function
+        if (node.type === "function_definition")
+            return;
+        if (node.type === "if_statement") {
+            const kids = namedChildren(node);
+            const cond = kids.find((c) => c.type === "test_command" ||
+                c.type === "condition" ||
+                c.type === "command" ||
+                c.type === "list" ||
+                c.type === "parenthesized_expression" ||
+                c.type === "unary_expression" ||
+                c.type === "binary_expression" ||
+                c.type === "negated_command" ||
+                c.type === "subscript" ||
+                c.type === "variable_name" ||
+                c.type === "string" ||
+                c.type === "word") ?? kids[0] ?? null;
+            // Prefer test_command text
+            const test = childByType(node, "test_command") ?? cond;
+            const condText = test ? collapseWs(test.text) : "";
+            // Consequent: statements before else/elif clauses
+            const elseClause = childByType(node, "else_clause");
+            const elifClauses = namedChildren(node).filter((c) => c.type === "elif_clause");
+            const consequent = kids.filter((c) => !sameNode(c, test) &&
+                c.type !== "else_clause" &&
+                c.type !== "elif_clause" &&
+                c.type !== "test_command");
+            // If first kid is the condition already captured as test, drop it from consequent
+            const thenStmts = consequent.filter((c) => !sameNode(c, cond));
+            steps.push({
+                type: "branch",
+                key: condText ? `if:${condText}` : "if",
+                label: condText ? `if ${condText}` : "if",
+                ...locFromNode(file, test ?? node),
+                children: collectStatements(file, thenStmts),
+            });
+            for (const clause of elifClauses) {
+                const elifKids = namedChildren(clause);
+                const elifTest = childByType(clause, "test_command") ?? elifKids[0] ?? null;
+                const text = elifTest ? collapseWs(elifTest.text) : "";
+                const body = elifKids.filter((c) => !sameNode(c, elifTest));
+                steps.push({
+                    type: "branch",
+                    key: text ? `else-if:${text}` : "else-if",
+                    label: text ? `elif ${text}` : "elif",
+                    ...locFromNode(file, elifTest ?? clause),
+                    children: collectStatements(file, body),
+                });
+            }
+            if (elseClause) {
+                steps.push({
+                    type: "branch",
+                    key: "else",
+                    label: "else",
+                    ...locFromNode(file, elseClause),
+                    children: collectStatements(file, namedChildren(elseClause)),
+                });
+            }
+            return;
+        }
+        if (node.type === "case_statement") {
+            for (const item of namedChildren(node)) {
+                if (item.type !== "case_item")
+                    continue;
+                const kids = namedChildren(item);
+                const pattern = kids.find((c) => c.type === "word" ||
+                    c.type === "string" ||
+                    c.type === "raw_string" ||
+                    c.type === "extglob_pattern" ||
+                    c.type === "concatenation" ||
+                    c.type === "ansi_c_string") ?? kids[0] ?? null;
+                const text = pattern ? collapseWs(pattern.text) : "";
+                const body = kids.filter((c) => !sameNode(c, pattern));
+                steps.push({
+                    type: "branch",
+                    key: text ? `case:${text}` : "case",
+                    label: text ? `case ${text}` : "case",
+                    ...locFromNode(file, pattern ?? item),
+                    children: collectStatements(file, body),
+                });
+            }
+            return;
+        }
+        if (node.type === "command") {
+            const name = commandName(node);
+            if (name)
+                addCall(name, node);
+            // Walk args / substitutions (including when the name itself is $(...))
+            for (const child of namedChildren(node)) {
+                if (name && child.type === "command_name")
+                    continue;
+                walk(child);
+            }
+            return;
+        }
+        if (node.type === "command_substitution") {
+            for (const child of namedChildren(node))
+                walk(child);
+            return;
+        }
+        for (const child of namedChildren(node))
+            walk(child);
+    };
+    for (const stmt of statements)
+        walk(stmt);
+    return steps;
+}
+function handleFunction(file, node, functions) {
+    const name = childByType(node, "word")?.text ??
+        namedChildren(node).find((c) => c.type === "word")?.text ??
+        null;
+    if (!name)
+        return;
+    const body = childByType(node, "compound_statement") ??
+        childByType(node, "subshell") ??
+        childByType(node, "test_command") ??
+        null;
+    const stmts = body ? namedChildren(body) : [];
+    functions.push({
+        key: name,
+        label: `${name}()`,
+        file,
+        steps: collectStatements(file, stmts),
+        exported: true,
+        start: node.startIndex,
+        end: node.endIndex,
+    });
+}
+function extractFromTree(file, _source, tree) {
+    const functions = [];
+    for (const stmt of namedChildren(tree.rootNode)) {
+        if (stmt.type === "function_definition") {
+            handleFunction(file, stmt, functions);
+        }
+    }
+    return functions;
+}
+export const bashExtractor = {
+    id: "bash",
+    extensions: [".sh", ".bash"],
+    grammarPackage: "tree-sitter-bash",
+    extract: extractFromTree,
+};

package/dist/languages/c.d.ts

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

package/dist/languages/c.js

@@ -0,0 +1,218 @@
+import { heuristicCallSyntax } from "./call-syntax.js";
+import { childByType, declaredParamsOf, collapseWs, locFromNode, namedChildren, sameNode, } from "./types.js";
+function hasStatic(node) {
+    return namedChildren(node).some((c) => c.type === "storage_class_specifier" && c.text === "static");
+}
+function unwrapDeclarator(node) {
+    let cur = node;
+    while (cur) {
+        if (cur.type === "function_declarator")
+            return cur;
+        const next = childByType(cur, "function_declarator") ??
+            childByType(cur, "pointer_declarator") ??
+            childByType(cur, "parenthesized_declarator") ??
+            childByType(cur, "array_declarator") ??
+            null;
+        if (!next || sameNode(next, cur))
+            break;
+        cur = next;
+    }
+    return cur?.type === "function_declarator" ? cur : null;
+}
+function functionName(def) {
+    const declarator = unwrapDeclarator(namedChildren(def).find((c) => c.type === "function_declarator" ||
+        c.type === "pointer_declarator" ||
+        c.type === "parenthesized_declarator") ?? null) ?? childByType(def, "function_declarator");
+    if (!declarator)
+        return null;
+    return (childByType(declarator, "identifier")?.text ??
+        childByType(declarator, "field_identifier")?.text ??
+        null);
+}
+function getParamsLabel(def) {
+    const declarator = unwrapDeclarator(namedChildren(def).find((c) => c.type === "function_declarator" ||
+        c.type === "pointer_declarator" ||
+        c.type === "parenthesized_declarator") ?? null) ?? childByType(def, "function_declarator");
+    const params = declarator ? childByType(declarator, "parameter_list") : null;
+    if (!params)
+        return "()";
+    const names = [];
+    for (const p of namedChildren(params)) {
+        if (p.type !== "parameter_declaration")
+            continue;
+        if (p.text === "void")
+            continue;
+        const id = childByType(p, "identifier") ??
+            childByType(childByType(p, "pointer_declarator") ?? p, "identifier");
+        names.push(id?.text ?? "_");
+    }
+    return names.length === 0 ? "()" : `(${names.join(", ")})`;
+}
+function calleeKey(node) {
+    if (node.type === "identifier")
+        return node.text;
+    if (node.type === "field_expression") {
+        const object = node.namedChild(0);
+        const field = childByType(node, "field_identifier");
+        if (!object || !field)
+            return null;
+        if (object.type === "identifier") {
+            return `${object.text}.${field.text}`;
+        }
+        return field.text;
+    }
+    // Ignore computed / weird callees
+    return null;
+}
+function condText(node) {
+    if (!node)
+        return "";
+    if (node.type === "parenthesized_expression") {
+        const inner = node.namedChild(0);
+        if (inner)
+            return collapseWs(inner.text);
+    }
+    return collapseWs(node.text);
+}
+function collectStatements(file, statements) {
+    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 function definitions (GCC extension) — skip bodies
+        if (node.type === "function_definition")
+            return;
+        if (node.type === "if_statement") {
+            const cond = node.childForFieldName("condition") ??
+                childByType(node, "parenthesized_expression");
+            const consequent = node.childForFieldName("consequence") ??
+                namedChildren(node).find((c) => c.type !== "parenthesized_expression" && c.type !== "else_clause") ??
+                null;
+            const text = condText(cond);
+            steps.push({
+                type: "branch",
+                key: text ? `if:${text}` : "if",
+                label: text ? `if ${text}` : "if",
+                ...locFromNode(file, cond ?? node),
+                children: consequent ? collectStatements(file, [consequent]) : [],
+            });
+            let elseClause = childByType(node, "else_clause");
+            while (elseClause) {
+                const inner = elseClause.namedChild(0);
+                if (!inner)
+                    break;
+                if (inner.type === "if_statement") {
+                    const elifCond = inner.childForFieldName("condition") ??
+                        childByType(inner, "parenthesized_expression");
+                    const elifText = condText(elifCond);
+                    const elifCons = inner.childForFieldName("consequence") ??
+                        namedChildren(inner).find((c) => c.type !== "parenthesized_expression" &&
+                            c.type !== "else_clause") ??
+                        null;
+                    steps.push({
+                        type: "branch",
+                        key: elifText ? `else-if:${elifText}` : "else-if",
+                        label: elifText ? `else if ${elifText}` : "else if",
+                        ...locFromNode(file, elifCond ?? elseClause),
+                        children: elifCons ? collectStatements(file, [elifCons]) : [],
+                    });
+                    elseClause = childByType(inner, "else_clause");
+                    continue;
+                }
+                steps.push({
+                    type: "branch",
+                    key: "else",
+                    label: "else",
+                    ...locFromNode(file, elseClause),
+                    children: collectStatements(file, [inner]),
+                });
+                break;
+            }
+            return;
+        }
+        if (node.type === "switch_statement") {
+            const body = node.childForFieldName("body") ??
+                childByType(node, "compound_statement");
+            if (body) {
+                for (const clause of namedChildren(body)) {
+                    if (clause.type !== "case_statement")
+                        continue;
+                    const value = clause.childForFieldName("value");
+                    const kids = namedChildren(clause).filter((c) => !sameNode(c, value) && c.type !== "break_statement");
+                    if (value) {
+                        const text = collapseWs(value.text);
+                        steps.push({
+                            type: "branch",
+                            key: `case:${text}`,
+                            label: `case ${text}`,
+                            ...locFromNode(file, value),
+                            children: collectStatements(file, kids),
+                        });
+                    }
+                    else {
+                        steps.push({
+                            type: "branch",
+                            key: "default",
+                            label: "default",
+                            ...locFromNode(file, clause),
+                            children: collectStatements(file, kids),
+                        });
+                    }
+                }
+            }
+            return;
+        }
+        if (node.type === "call_expression") {
+            const callee = node.namedChild(0);
+            if (callee) {
+                const key = calleeKey(callee);
+                if (key)
+                    addCall(key, node);
+            }
+        }
+        for (const child of namedChildren(node))
+            walk(child);
+    };
+    for (const stmt of statements)
+        walk(stmt);
+    return steps;
+}
+function handleFunction(file, node, functions) {
+    const name = functionName(node);
+    if (!name)
+        return;
+    const body = childByType(node, "compound_statement");
+    functions.push({
+        key: name,
+        label: `${name}${getParamsLabel(node)}`,
+        params: declaredParamsOf(node),
+        file,
+        steps: body ? collectStatements(file, namedChildren(body)) : [],
+        exported: !hasStatic(node),
+        start: node.startIndex,
+        end: node.endIndex,
+    });
+}
+function extractFromTree(file, _source, tree) {
+    const functions = [];
+    for (const stmt of namedChildren(tree.rootNode)) {
+        if (stmt.type === "function_definition") {
+            handleFunction(file, stmt, functions);
+        }
+    }
+    return functions;
+}
+export const cExtractor = {
+    id: "c",
+    extensions: [".c", ".h"],
+    grammarPackage: "tree-sitter-c",
+    extract: extractFromTree,
+};

package/dist/languages/call-syntax.d.ts

@@ -0,0 +1,125 @@
+/**
+ * AST-side call metadata shared by every extractor: declared parameter lists,
+ * the arguments as written, lexical scopes for target classification, and the
+ * binder that pairs arguments with parameter slots.
+ *
+ * Nothing here invents a binding. A parameter slot is only named when the AST
+ * says so, and every lossy step records a reason from {@link CALL_REASONS}
+ * (spread, destructuring, unknown parameter list) instead of guessing.
+ */
+import { type CallArgument, type CallArgumentMapping, type CallArgumentSyntax, type CallContext, type CallSyntax, type CallTargetKind, type DeclaredParams } from "../types.js";
+import { type SyntaxNode } from "./types.js";
+/**
+ * Source text as written, cut to {@link MAX_ARGUMENT_CHARS}. The kept bytes are
+ * untouched: no collapsing, trimming, or re-quoting, so a truncated expression
+ * is still a byte-exact prefix of the source.
+ */
+export declare function cappedText(raw: string): Pick<CallArgument, "expression" | "truncated" | "originalLength">;
+/** Verbatim parameter list, parenthesised when the grammar omits the parens. */
+export declare function parameterText(params: SyntaxNode | null): string;
+/** Parameters known by text only: no slots, so binding stays unknown. */
+export declare function textOnlyParams(text: string): DeclaredParams;
+/** Declared parameters of a JS/TS function, arrow, or method node. */
+export declare function jsParameterList(params: SyntaxNode | null): DeclaredParams | undefined;
+/** Declared parameters of a Python function or lambda node. */
+export declare function pythonParameterList(params: SyntaxNode | null): DeclaredParams | undefined;
+export interface ArgumentReadResult {
+    args: CallArgumentSyntax[];
+    /** Number of written arguments omitted by the extraction limit. */
+    omitted: number;
+}
+/**
+ * Syntax for a call in a grammar without scope analysis: the target is the
+ * qualified name the extractor recognised, so its association with a definition
+ * stays a heuristic (`candidate`) and arguments are never matched to parameters.
+ * The arguments themselves are still read as written, because they come from
+ * the call node and are not inferred.
+ */
+export declare function heuristicCallSyntax(callNode: SyntaxNode, callee: string): CallSyntax;
+export interface BoundArguments {
+    mapping: CallArgumentMapping;
+    /** Parameter name per argument, aligned with the argument list. */
+    bound: (string | null)[];
+    reasons: string[];
+    /** At least one argument has no reliable parameter. */
+    partial: boolean;
+}
+/**
+ * Pair written arguments with declared slots. A slot is filled at most once and
+ * only by a name the AST actually declares; anything else leaves the argument
+ * unbound and marks the result partial with the reason why.
+ */
+export declare function bindArguments(params: DeclaredParams, args: readonly CallArgumentSyntax[]): BoundArguments;
+/** What the call tree learned about the callee's definition, if anything. */
+export interface CallResolution {
+    /** A definition was resolved for this call. */
+    resolved: boolean;
+    /** The resolved definition matches the lexical parameter AST in this file. */
+    lexical: boolean;
+}
+/**
+ * The public contract for one call site: the target expression as written, the
+ * callee's declared list, and the arguments with their bindings.
+ *
+ * A candidate target keeps `mapping: "unknown"`: the association is a name
+ * heuristic, so its bindings are never assumed.
+ */
+export declare function callContextFromSyntax(syntax: CallSyntax, params: DeclaredParams | undefined, resolution: CallResolution): CallContext;
+/** Syntax for a target the extractor cannot associate with any declaration. */
+export declare function dynamicSyntax(callee: string, args: ArgumentReadResult | undefined, reasons?: readonly string[]): CallSyntax;
+/** Syntax for a target whose binding is a name/member heuristic. */
+export declare function candidateSyntax(callee: string, args: ArgumentReadResult | undefined, reasons?: readonly string[]): CallSyntax;
+/** Syntax for a target a declaration in this file actually binds. */
+export declare function lexicalSyntax(callee: string, params: DeclaredParams | undefined, args: ArgumentReadResult | undefined, reasons?: readonly string[]): CallSyntax;
+/** One binding a lexical analysis found in the source. */
+export interface LocalBinding {
+    callable: boolean;
+    params?: DeclaredParams;
+    kind: "function" | "param" | "local" | "import" | "class";
+}
+/** A lexical scope; lookups walk outward through `parent`. */
+export interface Scope {
+    bindings: Map<string, LocalBinding>;
+    parent: Scope | null;
+    /** File-local syntactic writes, not inferred execution order or values. */
+    writes: Set<string>;
+}
+export declare function newScope(parent?: Scope | null): Scope;
+export declare function scopeLookup(scope: Scope | null, name: string): LocalBinding | undefined;
+/** Params and body declarations of one JS function/arrow/method node. */
+export declare function jsFunctionScope(node: SyntaxNode, parent: Scope | null): Scope;
+/**
+ * Module bindings of a JS/TS file: declarations and imports. Each statement is
+ * classified on its own, and an `export` is classified as what it declares.
+ */
+export declare function jsModuleScope(root: SyntaxNode): Scope;
+export interface CalleeTarget {
+    callee: string;
+    target: CallTargetKind;
+    params?: DeclaredParams;
+    reasons: string[];
+}
+/** Everything a JS/TS extraction knows at one call site. */
+export interface JsEnv {
+    scope: Scope;
+    className: string | null;
+}
+/**
+ * Classify plain, unambiguous declarations lexically. Imports and member
+ * dispatch remain candidates because this extractor does not resolve them.
+ */
+export declare function classifyJsCallee(node: SyntaxNode, env: JsEnv): CalleeTarget;
+/** Classified target plus arguments of one JS/TS call site. */
+export declare function jsCallSyntax(calleeNode: SyntaxNode | null, argsNode: SyntaxNode | null, env: JsEnv): CallSyntax | undefined;
+/** Params and body assignments of one Python function or lambda node. */
+export declare function pythonFunctionScope(node: SyntaxNode, parent: Scope | null): Scope;
+/** Module bindings of a Python file: defs, classes, imports, assignments. */
+export declare function pythonModuleScope(root: SyntaxNode): Scope;
+export interface PythonEnv {
+    scope: Scope;
+    className: string | null;
+}
+/** Python imports, decorators, and member dispatch do not establish a target. */
+export declare function classifyPythonCallee(node: SyntaxNode, env: PythonEnv): CalleeTarget;
+/** Classified target plus arguments of one Python call site. */
+export declare function pythonCallSyntax(calleeNode: SyntaxNode | null, argsNode: SyntaxNode | null, env: PythonEnv): CallSyntax | undefined;