diffninja 0.1.0

package/dist/languages/scala.js

@@ -0,0 +1,307 @@
+import { heuristicCallSyntax } from "./call-syntax.js";
+import { childByType, declaredParamsOf, collapseWs, locFromNode, namedChildren, } from "./types.js";
+function isPrivate(node) {
+    return /\bprivate\b|\bprotected\b/.test(namedChildren(node)
+        .filter((c) => c.type === "modifiers" || c.type === "access_modifier")
+        .map((c) => c.text)
+        .join(" ") || node.text.slice(0, 40));
+}
+function getParamsLabel(params) {
+    if (!params || params.type !== "parameters")
+        return "()";
+    const names = [];
+    for (const p of namedChildren(params)) {
+        if (p.type === "parameter") {
+            const id = childByType(p, "identifier");
+            names.push(id?.text ?? "_");
+        }
+    }
+    return names.length === 0 ? "()" : `(${names.join(", ")})`;
+}
+function isLikelyTypeName(name) {
+    const c = name[0];
+    return c !== undefined && c === c.toUpperCase() && c !== c.toLowerCase();
+}
+function calleeKey(node, typeName) {
+    if (node.type === "identifier") {
+        // Services() → constructor-style call (common Scala apply sugar)
+        if (isLikelyTypeName(node.text))
+            return `new ${node.text}`;
+        // Bare calls inside a class/object refer to siblings: prepare() → Runner.prepare
+        if (typeName)
+            return `${typeName}.${node.text}`;
+        return node.text;
+    }
+    if (node.type === "field_expression") {
+        const object = node.namedChild(0);
+        const field = node.namedChild(1);
+        if (!object || !field)
+            return null;
+        const prop = field.text;
+        if (object.type === "identifier") {
+            if ((object.text === "this" || object.text === "self") && typeName) {
+                return `${typeName}.${prop}`;
+            }
+            return `${object.text}.${prop}`;
+        }
+        if (typeName)
+            return `${typeName}.${prop}`;
+        return prop;
+    }
+    return null;
+}
+function statementsOf(body) {
+    if (!body)
+        return [];
+    if (body.type === "block")
+        return namedChildren(body);
+    return [body];
+}
+function collectStatements(file, statements, typeName) {
+    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 pushIfChain = (node, asElseIf) => {
+        const kids = namedChildren(node);
+        const blocks = kids.filter((c) => c.type === "block");
+        const nestedIf = kids.find((c) => c.type === "if_expression") ?? null;
+        const cond = childByType(node, "parenthesized_expression") ??
+            kids.find((c) => c.type !== "block" && c.type !== "if_expression") ??
+            null;
+        const condInner = cond?.type === "parenthesized_expression"
+            ? (cond.namedChild(0) ?? cond)
+            : cond;
+        const condText = condInner ? collapseWs(condInner.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, condInner ?? node),
+            children: collectStatements(file, statementsOf(blocks[0] ?? null), typeName),
+        });
+        if (nestedIf) {
+            pushIfChain(nestedIf, true);
+            return;
+        }
+        if (blocks[1]) {
+            steps.push({
+                type: "branch",
+                key: "else",
+                label: "else",
+                ...locFromNode(file, blocks[1]),
+                children: collectStatements(file, statementsOf(blocks[1]), typeName),
+            });
+        }
+    };
+    const walk = (node) => {
+        if (node.type === "function_definition" ||
+            node.type === "class_definition" ||
+            node.type === "object_definition" ||
+            node.type === "trait_definition" ||
+            node.type === "lambda_expression") {
+            return;
+        }
+        if (node.type === "if_expression") {
+            pushIfChain(node, false);
+            return;
+        }
+        if (node.type === "try_expression") {
+            const tryBlock = childByType(node, "block");
+            steps.push({
+                type: "branch",
+                key: "try",
+                label: "try",
+                ...locFromNode(file, node),
+                children: collectStatements(file, statementsOf(tryBlock), typeName),
+            });
+            for (const clause of namedChildren(node)) {
+                if (clause.type === "catch_clause") {
+                    const caseBlock = childByType(clause, "case_block");
+                    const cases = caseBlock ? namedChildren(caseBlock) : [];
+                    if (cases.length === 0) {
+                        steps.push({
+                            type: "branch",
+                            key: "catch",
+                            label: "catch",
+                            ...locFromNode(file, clause),
+                            children: collectStatements(file, namedChildren(clause), typeName),
+                        });
+                    }
+                    else {
+                        for (const c of cases) {
+                            if (c.type !== "case_clause")
+                                continue;
+                            const pattern = namedChildren(c).find((x) => x.type !== "block" &&
+                                x.type !== "call_expression" &&
+                                x.type !== "infix_expression") ?? namedChildren(c)[0] ?? null;
+                            const text = pattern ? collapseWs(pattern.text) : "";
+                            const bodyNodes = namedChildren(c).slice(1);
+                            steps.push({
+                                type: "branch",
+                                key: text ? `catch:${text}` : "catch",
+                                label: text ? `catch ${text}` : "catch",
+                                ...locFromNode(file, pattern ?? c),
+                                children: collectStatements(file, bodyNodes, typeName),
+                            });
+                        }
+                    }
+                }
+                if (clause.type === "finally_clause") {
+                    const body = childByType(clause, "block") ?? clause.namedChild(0) ?? null;
+                    steps.push({
+                        type: "branch",
+                        key: "finally",
+                        label: "finally",
+                        ...locFromNode(file, clause),
+                        children: collectStatements(file, statementsOf(body), typeName),
+                    });
+                }
+            }
+            return;
+        }
+        if (node.type === "match_expression") {
+            const caseBlock = childByType(node, "case_block");
+            for (const clause of caseBlock ? namedChildren(caseBlock) : []) {
+                if (clause.type !== "case_clause")
+                    continue;
+                const kids = namedChildren(clause);
+                const pattern = kids[0] ?? null;
+                const text = pattern ? collapseWs(pattern.text) : "";
+                const bodyNodes = kids.slice(1);
+                steps.push({
+                    type: "branch",
+                    key: text ? `case:${text}` : "case",
+                    label: text ? `case ${text}` : "case",
+                    ...locFromNode(file, pattern ?? clause),
+                    children: collectStatements(file, bodyNodes, typeName),
+                });
+            }
+            return;
+        }
+        if (node.type === "call_expression") {
+            const callee = node.namedChild(0);
+            if (callee) {
+                const key = calleeKey(callee, typeName);
+                if (key)
+                    addCall(key, node);
+            }
+            for (const child of namedChildren(node).slice(1))
+                walk(child);
+            return;
+        }
+        if (node.type === "instance_expression") {
+            // new Foo(args)
+            const typeId = childByType(node, "type_identifier");
+            if (typeId)
+                addCall(`new ${typeId.text}`, node);
+            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, typeName, functions) {
+    const name = childByType(node, "identifier")?.text ?? null;
+    if (!name)
+        return;
+    const params = childByType(node, "parameters");
+    const body = childByType(node, "block") ??
+        namedChildren(node).find((c) => c.type !== "identifier" &&
+            c.type !== "parameters" &&
+            c.type !== "type_identifier" &&
+            c.type !== "modifiers" &&
+            c.type !== "access_modifier" &&
+            c.type !== "singleton_type") ??
+        null;
+    const key = typeName ? `${typeName}.${name}` : name;
+    const exported = !isPrivate(node);
+    const steps = collectStatements(file, statementsOf(body), typeName);
+    functions.push({
+        key,
+        label: `${key}${getParamsLabel(params)}`,
+        params: declaredParamsOf(node),
+        file,
+        steps,
+        exported,
+        start: node.startIndex,
+        end: node.endIndex,
+    });
+    // object Foo { def apply(...) } → also index as constructor alias
+    if (typeName && name === "apply") {
+        functions.push({
+            key: `new ${typeName}`,
+            label: `${typeName}${getParamsLabel(params)}`,
+            params: declaredParamsOf(node),
+            file,
+            steps,
+            exported,
+            start: node.startIndex,
+            end: node.endIndex,
+        });
+    }
+    // class Foo { def this(...) } → secondary constructor alias
+    if (typeName && name === "this") {
+        functions.push({
+            key: `new ${typeName}`,
+            label: `${typeName}${getParamsLabel(params)}`,
+            file,
+            steps,
+            exported,
+            start: node.startIndex,
+            end: node.endIndex,
+        });
+    }
+}
+function handleTemplate(file, node, functions) {
+    const typeName = childByType(node, "identifier")?.text ?? null;
+    if (!typeName)
+        return;
+    const body = childByType(node, "template_body");
+    if (!body)
+        return;
+    for (const element of namedChildren(body)) {
+        if (element.type === "function_definition") {
+            handleFunction(file, element, typeName, functions);
+        }
+        else if (element.type === "class_definition" ||
+            element.type === "object_definition" ||
+            element.type === "trait_definition") {
+            handleTemplate(file, element, functions);
+        }
+    }
+}
+function extractFromTree(file, _source, tree) {
+    const functions = [];
+    for (const stmt of namedChildren(tree.rootNode)) {
+        if (stmt.type === "function_definition") {
+            handleFunction(file, stmt, null, functions);
+        }
+        else if (stmt.type === "class_definition" ||
+            stmt.type === "object_definition" ||
+            stmt.type === "trait_definition") {
+            handleTemplate(file, stmt, functions);
+        }
+    }
+    return functions;
+}
+export const scalaExtractor = {
+    id: "scala",
+    extensions: [".scala"],
+    grammarPackage: "tree-sitter-scala",
+    extract: extractFromTree,
+};

package/dist/languages/solidity.d.ts

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

package/dist/languages/solidity.js

@@ -0,0 +1,240 @@
+import { heuristicCallSyntax } from "./call-syntax.js";
+import { childByType, collapseWs, locFromNode, namedChildren, } from "./types.js";
+function getParamsLabel(fn) {
+    const names = [];
+    for (const c of namedChildren(fn)) {
+        if (c.type !== "parameter")
+            continue;
+        const id = childByType(c, "identifier");
+        names.push(id?.text ?? "_");
+    }
+    return names.length === 0 ? "()" : `(${names.join(", ")})`;
+}
+function typeNameFrom(node) {
+    if (!node)
+        return null;
+    if (node.type === "identifier")
+        return node.text;
+    if (node.type === "user_defined_type" || node.type === "type_name") {
+        const id = childByType(node, "identifier") ?? childByType(node, "user_defined_type");
+        if (id?.type === "identifier")
+            return id.text;
+        return typeNameFrom(id);
+    }
+    const id = childByType(node, "identifier");
+    return id?.text ?? null;
+}
+function calleeKey(node, contractName) {
+    if (node.type === "identifier") {
+        // Bare call inside contract → Contract.fn (local)
+        if (contractName)
+            return `${contractName}.${node.text}`;
+        return node.text;
+    }
+    if (node.type === "member_expression") {
+        const object = node.namedChild(0);
+        const prop = node.namedChild(1);
+        if (!prop)
+            return null;
+        const propName = prop.text;
+        if (object?.type === "identifier") {
+            if (object.text === "this" && contractName) {
+                return `${contractName}.${propName}`;
+            }
+            return `${object.text}.${propName}`;
+        }
+        if (contractName)
+            return `${contractName}.${propName}`;
+        return propName;
+    }
+    if (node.type === "new_expression") {
+        const t = typeNameFrom(childByType(node, "type_name")) ??
+            typeNameFrom(childByType(node, "user_defined_type")) ??
+            typeNameFrom(node.namedChild(0));
+        return t ? `new ${t}` : null;
+    }
+    return null;
+}
+function statementsOf(body) {
+    if (!body)
+        return [];
+    if (body.type === "function_body" || body.type === "block_statement") {
+        return namedChildren(body);
+    }
+    if (body.type === "statement") {
+        return namedChildren(body);
+    }
+    return [body];
+}
+function unwrapStatement(stmt) {
+    if (stmt.type === "statement" && stmt.namedChildCount === 1) {
+        return stmt.namedChild(0) ?? stmt;
+    }
+    return stmt;
+}
+function collectStatements(file, statements, contractName) {
+    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 === "constructor_definition" ||
+            node.type === "modifier_definition" ||
+            node.type === "contract_declaration" ||
+            node.type === "library_declaration" ||
+            node.type === "interface_declaration") {
+            return;
+        }
+        if (node.type === "if_statement") {
+            const kids = namedChildren(node);
+            const cond = kids.find((c) => c.type !== "statement" &&
+                c.type !== "block_statement") ?? kids[0] ?? null;
+            const bodies = kids.filter((c) => c.type === "statement" || c.type === "block_statement");
+            const condText = cond ? collapseWs(cond.text) : "";
+            const thenNode = bodies[0] ? unwrapStatement(bodies[0]) : null;
+            const elseNode = bodies[1] ? unwrapStatement(bodies[1]) : null;
+            steps.push({
+                type: "branch",
+                key: condText ? `if:${condText}` : "if",
+                label: condText ? `if ${condText}` : "if",
+                ...locFromNode(file, cond ?? node),
+                children: thenNode
+                    ? collectStatements(file, statementsOf(thenNode), contractName)
+                    : [],
+            });
+            if (elseNode) {
+                if (elseNode.type === "if_statement") {
+                    const nested = collectStatements(file, [elseNode], contractName);
+                    for (const s of nested) {
+                        if (s.type === "branch" && (s.key === "if" || s.key.startsWith("if:"))) {
+                            steps.push({
+                                ...s,
+                                key: s.key === "if" ? "else-if" : s.key.replace(/^if:/, "else-if:"),
+                                label: s.label.replace(/^if /, "else if "),
+                            });
+                        }
+                        else {
+                            steps.push(s);
+                        }
+                    }
+                }
+                else {
+                    steps.push({
+                        type: "branch",
+                        key: "else",
+                        label: "else",
+                        ...locFromNode(file, elseNode),
+                        children: collectStatements(file, statementsOf(elseNode), contractName),
+                    });
+                }
+            }
+            return;
+        }
+        if (node.type === "call_expression") {
+            const callee = childByType(node, "expression")?.namedChild?.(0) ??
+                childByType(node, "expression") ??
+                node.namedChild(0);
+            // expression → identifier | member_expression | new_expression
+            let target = callee;
+            if (callee?.type === "expression") {
+                target = callee.namedChild(0) ?? callee;
+            }
+            if (target) {
+                const key = calleeKey(target, contractName);
+                if (key)
+                    addCall(key, node);
+            }
+            for (const child of namedChildren(node).slice(1))
+                walk(child);
+            return;
+        }
+        for (const child of namedChildren(node))
+            walk(child);
+    };
+    for (const stmt of statements)
+        walk(unwrapStatement(stmt));
+    return steps;
+}
+function handleFunction(file, node, contractName, functions) {
+    const name = childByType(node, "identifier")?.text ?? null;
+    if (!name)
+        return;
+    const body = childByType(node, "function_body");
+    const key = contractName ? `${contractName}.${name}` : name;
+    const visibility = childByType(node, "visibility")?.text;
+    functions.push({
+        key,
+        label: `${key}${getParamsLabel(node)}`,
+        file,
+        steps: body
+            ? collectStatements(file, statementsOf(body), contractName)
+            : [],
+        exported: visibility !== "private" && visibility !== "internal",
+        start: node.startIndex,
+        end: node.endIndex,
+    });
+}
+function handleConstructor(file, node, contractName, functions) {
+    const body = childByType(node, "function_body");
+    const info = {
+        key: `${contractName}.constructor`,
+        label: `new ${contractName}${getParamsLabel(node)}`,
+        file,
+        steps: body
+            ? collectStatements(file, statementsOf(body), contractName)
+            : [],
+        exported: true,
+        start: node.startIndex,
+        end: node.endIndex,
+    };
+    functions.push(info);
+    functions.push({
+        ...info,
+        key: `new ${contractName}`,
+        label: `new ${contractName}()`,
+    });
+}
+function handleContractLike(file, node, functions) {
+    const name = childByType(node, "identifier")?.text ?? null;
+    if (!name)
+        return;
+    const body = childByType(node, "contract_body") ?? childByType(node, "interface_body");
+    if (!body)
+        return;
+    for (const child of namedChildren(body)) {
+        if (child.type === "function_definition") {
+            handleFunction(file, child, name, functions);
+        }
+        else if (child.type === "constructor_definition") {
+            handleConstructor(file, child, name, functions);
+        }
+    }
+}
+function extractFromTree(file, _source, tree) {
+    const functions = [];
+    for (const stmt of namedChildren(tree.rootNode)) {
+        if (stmt.type === "contract_declaration" ||
+            stmt.type === "library_declaration" ||
+            stmt.type === "interface_declaration") {
+            handleContractLike(file, stmt, functions);
+        }
+        else if (stmt.type === "function_definition") {
+            handleFunction(file, stmt, null, functions);
+        }
+    }
+    return functions;
+}
+export const solidityExtractor = {
+    id: "solidity",
+    extensions: [".sol"],
+    grammarPackage: "tree-sitter-solidity",
+    extract: extractFromTree,
+};

package/dist/languages/swift.d.ts

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