diffninja 0.1.0

package/dist/languages/cpp.d.ts

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

package/dist/languages/cpp.js

@@ -0,0 +1,321 @@
+import { heuristicCallSyntax } from "./call-syntax.js";
+import { childByType, declaredParamsOf, collapseWs, locFromNode, namedChildren, sameNode, } from "./types.js";
+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, "reference_declarator") ??
+            childByType(cur, "parenthesized_declarator") ??
+            null;
+        if (!next || sameNode(next, cur))
+            break;
+        cur = next;
+    }
+    return cur?.type === "function_declarator" ? cur : null;
+}
+function getParamsLabel(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") ??
+            childByType(childByType(p, "reference_declarator") ?? p, "identifier");
+        names.push(id?.text ?? "_");
+    }
+    return names.length === 0 ? "()" : `(${names.join(", ")})`;
+}
+function calleeKey(node, className) {
+    if (node.type === "identifier") {
+        return node.text;
+    }
+    if (node.type === "type_identifier") {
+        // Rare as a bare callee; prefer not inventing `new`
+        return node.text;
+    }
+    if (node.type === "qualified_identifier") {
+        // std::foo / Foo::bar — normalize :: to . for Class.method keys
+        return collapseWs(node.text).replace(/\s+/g, "").replace(/::/g, ".");
+    }
+    if (node.type === "field_expression") {
+        const object = node.namedChild(0);
+        const field = childByType(node, "field_identifier");
+        if (!object || !field)
+            return null;
+        const prop = field.text;
+        if (object.type === "this" && className) {
+            return `${className}.${prop}`;
+        }
+        if (object.type === "identifier") {
+            return `${object.text}.${prop}`;
+        }
+        if (className)
+            return `${className}.${prop}`;
+        return prop;
+    }
+    return null;
+}
+function condText(node) {
+    if (!node)
+        return "";
+    if (node.type === "condition_clause" || node.type === "parenthesized_expression") {
+        const inner = node.namedChild(0);
+        if (inner)
+            return collapseWs(inner.text);
+    }
+    return collapseWs(node.text);
+}
+function collectStatements(file, statements, className) {
+    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) => {
+        if (node.type === "function_definition" ||
+            node.type === "lambda_expression" ||
+            node.type === "class_specifier" ||
+            node.type === "struct_specifier") {
+            return;
+        }
+        if (node.type === "if_statement") {
+            const cond = node.childForFieldName("condition") ??
+                childByType(node, "condition_clause") ??
+                childByType(node, "parenthesized_expression");
+            const consequent = node.childForFieldName("consequence") ??
+                namedChildren(node).find((c) => c.type !== "condition_clause" &&
+                    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], className)
+                    : [],
+            });
+            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, "condition_clause");
+                    const elifText = condText(elifCond);
+                    const elifCons = inner.childForFieldName("consequence") ??
+                        namedChildren(inner).find((c) => c.type !== "condition_clause" &&
+                            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], className)
+                            : [],
+                    });
+                    elseClause = childByType(inner, "else_clause");
+                    continue;
+                }
+                steps.push({
+                    type: "branch",
+                    key: "else",
+                    label: "else",
+                    ...locFromNode(file, elseClause),
+                    children: collectStatements(file, [inner], className),
+                });
+                break;
+            }
+            return;
+        }
+        if (node.type === "try_statement") {
+            const body = node.childForFieldName("body") ??
+                childByType(node, "compound_statement");
+            steps.push({
+                type: "branch",
+                key: "try",
+                label: "try",
+                ...locFromNode(file, node),
+                children: body
+                    ? collectStatements(file, namedChildren(body), className)
+                    : [],
+            });
+            for (const clause of namedChildren(node)) {
+                if (clause.type !== "catch_clause")
+                    continue;
+                const params = childByType(clause, "parameter_list");
+                const text = params ? collapseWs(params.text) : "";
+                const catchBody = clause.childForFieldName("body") ??
+                    childByType(clause, "compound_statement");
+                steps.push({
+                    type: "branch",
+                    key: text ? `catch:${text}` : "catch",
+                    label: text ? `catch ${text}` : "catch",
+                    ...locFromNode(file, params ?? clause),
+                    children: catchBody
+                        ? collectStatements(file, namedChildren(catchBody), className)
+                        : [],
+                });
+            }
+            return;
+        }
+        if (node.type === "call_expression") {
+            const callee = node.namedChild(0);
+            if (callee) {
+                const key = calleeKey(callee, className);
+                if (key)
+                    addCall(key, node);
+            }
+        }
+        else if (node.type === "new_expression") {
+            const typeId = childByType(node, "type_identifier") ??
+                namedChildren(node).find((c) => c.type === "type_identifier" || c.type === "qualified_identifier") ??
+                null;
+            if (typeId) {
+                const name = collapseWs(typeId.text);
+                addCall(`new ${name}`, node);
+            }
+        }
+        for (const child of namedChildren(node))
+            walk(child);
+    };
+    for (const stmt of statements)
+        walk(stmt);
+    return steps;
+}
+function pushFunction(file, node, key, label, declarator, body, className, exported, functions) {
+    const info = {
+        key,
+        label: `${label}${getParamsLabel(declarator)}`,
+        params: declarator ? declaredParamsOf(declarator) : undefined,
+        file,
+        steps: body ? collectStatements(file, namedChildren(body), className) : [],
+        exported,
+        start: node.startIndex,
+        end: node.endIndex,
+    };
+    functions.push(info);
+}
+function handleFreeFunction(file, node, functions) {
+    const rawDecl = namedChildren(node).find((c) => c.type === "function_declarator" ||
+        c.type === "pointer_declarator" ||
+        c.type === "reference_declarator") ?? null;
+    const declarator = unwrapDeclarator(rawDecl);
+    if (!declarator)
+        return;
+    if (childByType(declarator, "destructor_name"))
+        return;
+    const name = childByType(declarator, "identifier")?.text ??
+        childByType(declarator, "field_identifier")?.text ??
+        null;
+    if (!name)
+        return;
+    const body = childByType(node, "compound_statement");
+    pushFunction(file, node, name, name, declarator, body, null, true, functions);
+}
+function handleClassMethod(file, node, className, functions) {
+    const rawDecl = namedChildren(node).find((c) => c.type === "function_declarator" ||
+        c.type === "pointer_declarator" ||
+        c.type === "reference_declarator") ?? null;
+    const declarator = unwrapDeclarator(rawDecl);
+    if (!declarator)
+        return;
+    const dtor = childByType(declarator, "destructor_name");
+    if (dtor) {
+        // Skip destructors for callgraph indexing
+        return;
+    }
+    const nameNode = childByType(declarator, "identifier") ??
+        childByType(declarator, "field_identifier");
+    const name = nameNode?.text ?? null;
+    if (!name)
+        return;
+    const body = childByType(node, "compound_statement");
+    const isCtor = name === className;
+    const key = isCtor ? `${className}.constructor` : `${className}.${name}`;
+    const label = isCtor ? `new ${className}` : key;
+    pushFunction(file, node, key, label, declarator, body, className, true, functions);
+    if (isCtor) {
+        const ctor = functions[functions.length - 1];
+        functions.push({
+            ...ctor,
+            key: `new ${className}`,
+            label: `new ${className}${getParamsLabel(declarator)}`,
+            params: declaredParamsOf(declarator),
+        });
+    }
+}
+function handleClass(file, node, functions) {
+    const className = childByType(node, "type_identifier")?.text ??
+        childByType(node, "identifier")?.text ??
+        null;
+    if (!className)
+        return;
+    const body = childByType(node, "field_declaration_list");
+    if (!body)
+        return;
+    for (const member of namedChildren(body)) {
+        if (member.type === "function_definition") {
+            handleClassMethod(file, member, className, functions);
+        }
+    }
+}
+function visit(file, node, functions) {
+    if (node.type === "function_definition") {
+        handleFreeFunction(file, node, functions);
+        return;
+    }
+    if (node.type === "class_specifier" ||
+        node.type === "struct_specifier") {
+        handleClass(file, node, functions);
+        return;
+    }
+    if (node.type === "namespace_definition" || node.type === "declaration_list") {
+        for (const child of namedChildren(node))
+            visit(file, child, functions);
+        return;
+    }
+    // `class Foo { ... };` may wrap as type declaration — walk named children lightly
+    if (node.type === "declaration") {
+        for (const child of namedChildren(node)) {
+            if (child.type === "class_specifier" ||
+                child.type === "struct_specifier" ||
+                child.type === "namespace_definition") {
+                visit(file, child, functions);
+            }
+        }
+    }
+}
+function extractFromTree(file, _source, tree) {
+    const functions = [];
+    for (const stmt of namedChildren(tree.rootNode)) {
+        visit(file, stmt, functions);
+    }
+    return functions;
+}
+export const cppExtractor = {
+    id: "cpp",
+    extensions: [".cc", ".cpp", ".cu", ".cuh", ".cxx", ".hpp", ".hh"],
+    grammarPackage: "tree-sitter-cpp",
+    extract: extractFromTree,
+};

package/dist/languages/csharp.d.ts

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

package/dist/languages/csharp.js

@@ -0,0 +1,324 @@
+import { heuristicCallSyntax } from "./call-syntax.js";
+import { childByType, declaredParamsOf, collapseWs, locFromNode, namedChildren, sameNode, } from "./types.js";
+function isPrivate(node) {
+    return namedChildren(node).some((c) => c.type === "modifier" && c.text === "private");
+}
+function getParamsLabel(params) {
+    if (!params || params.type !== "parameter_list")
+        return "()";
+    const names = [];
+    for (const p of namedChildren(params)) {
+        if (p.type !== "parameter")
+            continue;
+        const id = childByType(p, "identifier");
+        names.push(id?.text ?? "_");
+    }
+    return names.length === 0 ? "()" : `(${names.join(", ")})`;
+}
+function memberAccessKey(node, className) {
+    // this.Foo → unnamed "this" child + named property identifier
+    const first = node.child(0);
+    const ids = namedChildren(node).filter((c) => c.type === "identifier");
+    if (first?.type === "this" || first?.text === "this") {
+        const prop = ids[0]?.text;
+        if (!prop)
+            return null;
+        return className ? `${className}.${prop}` : prop;
+    }
+    if (ids.length >= 2) {
+        return `${ids[0].text}.${ids[1].text}`;
+    }
+    if (ids.length === 1) {
+        // Unusual single-identifier member access
+        return ids[0].text;
+    }
+    return null;
+}
+function calleeKey(node, className) {
+    if (node.type === "identifier")
+        return node.text;
+    if (node.type === "member_access_expression") {
+        return memberAccessKey(node, className);
+    }
+    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, className) {
+    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) => {
+        if (node.type === "method_declaration" ||
+            node.type === "constructor_declaration" ||
+            node.type === "local_function_statement" ||
+            node.type === "anonymous_method_expression" ||
+            node.type === "lambda_expression" ||
+            node.type === "class_declaration" ||
+            node.type === "struct_declaration" ||
+            node.type === "record_declaration") {
+            return;
+        }
+        if (node.type === "if_statement") {
+            const cond = node.childForFieldName("condition") ?? node.namedChild(0) ?? null;
+            const consequent = node.childForFieldName("consequence") ??
+                namedChildren(node).find((c, i) => i > 0) ??
+                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.type === "block"
+                        ? namedChildren(consequent)
+                        : [consequent], className)
+                    : [],
+            });
+            let alternative = node.childForFieldName("alternative");
+            while (alternative) {
+                if (alternative.type === "if_statement") {
+                    const elifCond = alternative.childForFieldName("condition") ??
+                        alternative.namedChild(0) ??
+                        null;
+                    const elifText = condText(elifCond);
+                    const elifCons = alternative.childForFieldName("consequence") ?? null;
+                    steps.push({
+                        type: "branch",
+                        key: elifText ? `else-if:${elifText}` : "else-if",
+                        label: elifText ? `else if ${elifText}` : "else if",
+                        ...locFromNode(file, elifCond ?? alternative),
+                        children: elifCons
+                            ? collectStatements(file, elifCons.type === "block"
+                                ? namedChildren(elifCons)
+                                : [elifCons], className)
+                            : [],
+                    });
+                    alternative = alternative.childForFieldName("alternative");
+                    continue;
+                }
+                steps.push({
+                    type: "branch",
+                    key: "else",
+                    label: "else",
+                    ...locFromNode(file, alternative),
+                    children: collectStatements(file, alternative.type === "block"
+                        ? namedChildren(alternative)
+                        : [alternative], className),
+                });
+                break;
+            }
+            return;
+        }
+        if (node.type === "try_statement") {
+            const body = node.childForFieldName("body") ?? childByType(node, "block");
+            steps.push({
+                type: "branch",
+                key: "try",
+                label: "try",
+                ...locFromNode(file, node),
+                children: body
+                    ? collectStatements(file, namedChildren(body), className)
+                    : [],
+            });
+            for (const clause of namedChildren(node)) {
+                if (clause.type === "catch_clause") {
+                    const decl = childByType(clause, "catch_declaration");
+                    const text = decl ? collapseWs(decl.text) : "";
+                    const catchBody = clause.childForFieldName("body") ?? childByType(clause, "block");
+                    steps.push({
+                        type: "branch",
+                        key: text ? `catch:${text}` : "catch",
+                        label: text ? `catch ${text}` : "catch",
+                        ...locFromNode(file, decl ?? clause),
+                        children: catchBody
+                            ? collectStatements(file, namedChildren(catchBody), className)
+                            : [],
+                    });
+                }
+                if (clause.type === "finally_clause") {
+                    const finallyBody = clause.childForFieldName("body") ?? childByType(clause, "block");
+                    steps.push({
+                        type: "branch",
+                        key: "finally",
+                        label: "finally",
+                        ...locFromNode(file, clause),
+                        children: finallyBody
+                            ? collectStatements(file, namedChildren(finallyBody), className)
+                            : [],
+                    });
+                }
+            }
+            return;
+        }
+        if (node.type === "switch_statement") {
+            const body = node.childForFieldName("body") ?? childByType(node, "switch_body");
+            if (body) {
+                for (const section of namedChildren(body)) {
+                    if (section.type !== "switch_section")
+                        continue;
+                    const pattern = namedChildren(section).find((c) => c.type === "constant_pattern" ||
+                        c.type === "declaration_pattern" ||
+                        c.type === "var_pattern" ||
+                        c.type === "discard_pattern") ?? null;
+                    const isDefault = [...Array(section.childCount)]
+                        .map((_, i) => section.child(i))
+                        .some((c) => c?.type === "default" || c?.text === "default");
+                    const stmts = namedChildren(section).filter((c) => !sameNode(c, pattern) &&
+                        c.type !== "break_statement" &&
+                        c.type !== "constant_pattern" &&
+                        c.type !== "declaration_pattern" &&
+                        c.type !== "var_pattern" &&
+                        c.type !== "discard_pattern");
+                    if (isDefault && !pattern) {
+                        steps.push({
+                            type: "branch",
+                            key: "default",
+                            label: "default",
+                            ...locFromNode(file, section),
+                            children: collectStatements(file, stmts, className),
+                        });
+                    }
+                    else {
+                        const text = pattern ? collapseWs(pattern.text) : "";
+                        steps.push({
+                            type: "branch",
+                            key: text ? `case:${text}` : "case",
+                            label: text ? `case ${text}` : "case",
+                            ...locFromNode(file, pattern ?? section),
+                            children: collectStatements(file, stmts, className),
+                        });
+                    }
+                }
+            }
+            return;
+        }
+        if (node.type === "invocation_expression") {
+            const callee = node.namedChild(0);
+            if (callee) {
+                const key = calleeKey(callee, className);
+                if (key)
+                    addCall(key, node);
+            }
+        }
+        else if (node.type === "object_creation_expression") {
+            const typeId = childByType(node, "identifier") ??
+                childByType(node, "qualified_name") ??
+                namedChildren(node).find((c) => c.type === "identifier" || c.type === "qualified_name") ??
+                null;
+            if (typeId) {
+                addCall(`new ${collapseWs(typeId.text)}`, node);
+            }
+        }
+        for (const child of namedChildren(node))
+            walk(child);
+    };
+    for (const stmt of statements)
+        walk(stmt);
+    return steps;
+}
+function handleMethod(file, node, className, functions) {
+    const name = node.childForFieldName("name")?.text ??
+        // Fallback: last identifier (return type may precede the name)
+        [...namedChildren(node)].filter((c) => c.type === "identifier").at(-1)
+            ?.text ??
+        null;
+    if (!name)
+        return;
+    const params = childByType(node, "parameter_list");
+    const body = childByType(node, "block");
+    const key = `${className}.${name}`;
+    functions.push({
+        key,
+        label: `${key}${getParamsLabel(params)}`,
+        params: declaredParamsOf(node),
+        file,
+        steps: body ? collectStatements(file, namedChildren(body), className) : [],
+        exported: !isPrivate(node),
+        start: node.startIndex,
+        end: node.endIndex,
+    });
+}
+function handleConstructor(file, node, className, functions) {
+    const params = childByType(node, "parameter_list");
+    const body = childByType(node, "block");
+    const info = {
+        key: `${className}.constructor`,
+        label: `new ${className}${getParamsLabel(params)}`,
+        params: declaredParamsOf(node),
+        file,
+        steps: body ? collectStatements(file, namedChildren(body), className) : [],
+        exported: !isPrivate(node),
+        start: node.startIndex,
+        end: node.endIndex,
+    };
+    functions.push(info);
+    functions.push({
+        ...info,
+        key: `new ${className}`,
+    });
+}
+function handleClass(file, node, functions) {
+    const className = childByType(node, "identifier")?.text ?? null;
+    if (!className)
+        return;
+    const body = childByType(node, "declaration_list");
+    if (!body)
+        return;
+    for (const member of namedChildren(body)) {
+        if (member.type === "method_declaration") {
+            handleMethod(file, member, className, functions);
+        }
+        else if (member.type === "constructor_declaration") {
+            handleConstructor(file, member, className, functions);
+        }
+    }
+}
+function visit(file, node, functions) {
+    if (node.type === "class_declaration" ||
+        node.type === "struct_declaration" ||
+        node.type === "record_declaration") {
+        handleClass(file, node, functions);
+        return;
+    }
+    if (node.type === "namespace_declaration") {
+        const list = childByType(node, "declaration_list") ?? node;
+        for (const child of namedChildren(list))
+            visit(file, child, functions);
+        return;
+    }
+    if (node.type === "file_scoped_namespace_declaration") {
+        for (const child of namedChildren(node))
+            visit(file, child, functions);
+    }
+}
+function extractFromTree(file, _source, tree) {
+    const functions = [];
+    for (const stmt of namedChildren(tree.rootNode)) {
+        visit(file, stmt, functions);
+    }
+    return functions;
+}
+export const csharpExtractor = {
+    id: "csharp",
+    extensions: [".cs"],
+    grammarPackage: "tree-sitter-c-sharp",
+    extract: extractFromTree,
+};

package/dist/languages/elixir.d.ts

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