diffninja 0.1.0

package/dist/languages/ocaml.js

@@ -0,0 +1,291 @@
+import { heuristicCallSyntax } from "./call-syntax.js";
+import { childByType, collapseWs, locFromNode, namedChildren, } from "./types.js";
+function getParamsLabel(binding) {
+    const names = [];
+    for (const c of namedChildren(binding)) {
+        if (c.type !== "parameter")
+            continue;
+        const pat = childByType(c, "value_pattern") ??
+            childByType(c, "unit") ??
+            c.namedChild(0);
+        if (!pat) {
+            names.push("_");
+            continue;
+        }
+        if (pat.type === "unit")
+            continue; // `()` param → show as no-arg slot
+        names.push(pat.text);
+    }
+    return names.length === 0 ? "()" : `(${names.join(", ")})`;
+}
+function valuePathKey(node, moduleName) {
+    if (node.type === "value_name") {
+        return moduleName ? `${moduleName}.${node.text}` : node.text;
+    }
+    if (node.type === "value_path") {
+        const value = childByType(node, "value_name");
+        if (!value)
+            return null;
+        const modPath = childByType(node, "module_path");
+        if (modPath) {
+            // Flatten module_path text: Runner.Validate.x → keep as written
+            const mods = [];
+            const collectMods = (n) => {
+                for (const c of namedChildren(n)) {
+                    if (c.type === "module_path")
+                        collectMods(c);
+                    else if (c.type === "module_name")
+                        mods.push(c.text);
+                }
+            };
+            collectMods(modPath);
+            return mods.length > 0 ? `${mods.join(".")}.${value.text}` : value.text;
+        }
+        // Bare value inside module → Module.value
+        return moduleName ? `${moduleName}.${value.text}` : value.text;
+    }
+    if (node.type === "field_get_expression") {
+        const obj = node.namedChild(0);
+        const field = childByType(node, "field_path") ?? node.namedChild(1);
+        const fieldName = field && (childByType(field, "field_name")?.text ?? field.text);
+        if (!fieldName)
+            return null;
+        if (obj?.type === "value_path") {
+            const simple = childByType(obj, "value_name");
+            if (simple && !childByType(obj, "module_path")) {
+                return `${simple.text}.${fieldName}`;
+            }
+        }
+        return fieldName;
+    }
+    return null;
+}
+function collectExpr(file, node, moduleName) {
+    if (!node)
+        return [];
+    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 = (n) => {
+        // Nested functions
+        if (n.type === "fun_expression" ||
+            n.type === "function_expression" ||
+            n.type === "value_definition" ||
+            n.type === "let_binding" ||
+            n.type === "module_definition") {
+            // Nested lets/functions/modules are not attributed to the outer caller;
+            // `let x = e in body` is handled separately below.
+            return;
+        }
+        if (n.type === "let_expression") {
+            // let x = rhs in body — walk rhs + body; skip indexing nested binding
+            const vd = childByType(n, "value_definition");
+            if (vd) {
+                for (const b of namedChildren(vd)) {
+                    if (b.type !== "let_binding")
+                        continue;
+                    const hasParams = namedChildren(b).some((c) => c.type === "parameter");
+                    // Nested function bodies are not attributed to the outer caller
+                    if (hasParams)
+                        continue;
+                    // rhs is last non-parameter child
+                    const kids = namedChildren(b);
+                    const rhs = kids.find((c) => c.type !== "value_name" &&
+                        c.type !== "parameter" &&
+                        c.type !== "type_constraint") ?? kids[kids.length - 1] ?? null;
+                    if (rhs)
+                        walk(rhs);
+                }
+            }
+            // body is typically last named child
+            const body = namedChildren(n).find((c) => c.type !== "value_definition") ?? null;
+            if (body)
+                walk(body);
+            return;
+        }
+        if (n.type === "match_expression" || n.type === "try_expression") {
+            if (n.type === "try_expression") {
+                const tryBody = namedChildren(n).find((c) => c.type !== "match_case") ?? null;
+                steps.push({
+                    type: "branch",
+                    key: "try",
+                    label: "try",
+                    ...locFromNode(file, n),
+                    children: tryBody ? collectExpr(file, tryBody, moduleName) : [],
+                });
+            }
+            for (const clause of namedChildren(n)) {
+                if (clause.type !== "match_case")
+                    continue;
+                const kids = namedChildren(clause);
+                const body = kids[kids.length - 1] ?? null;
+                const pattern = kids.length > 1 ? kids[0] : null;
+                const text = pattern ? collapseWs(pattern.text) : "";
+                const labelKind = n.type === "try_expression" ? "with" : "case";
+                steps.push({
+                    type: "branch",
+                    key: text ? `${labelKind}:${text}` : labelKind,
+                    label: text ? `${labelKind} ${text}` : labelKind,
+                    ...locFromNode(file, pattern ?? clause),
+                    children: body ? collectExpr(file, body, moduleName) : [],
+                });
+            }
+            return;
+        }
+        if (n.type === "if_expression") {
+            const kids = namedChildren(n);
+            const thenClause = childByType(n, "then_clause");
+            const elseClause = childByType(n, "else_clause");
+            const cond = kids.find((c) => c.type !== "then_clause" && c.type !== "else_clause") ?? null;
+            const condText = cond ? collapseWs(cond.text) : "";
+            steps.push({
+                type: "branch",
+                key: condText ? `if:${condText}` : "if",
+                label: condText ? `if ${condText}` : "if",
+                ...locFromNode(file, cond ?? n),
+                children: thenClause
+                    ? collectExpr(file, thenClause.namedChild(0) ?? thenClause, moduleName)
+                    : [],
+            });
+            if (elseClause) {
+                const elseBody = elseClause.namedChild(0) ?? elseClause;
+                if (elseBody.type === "if_expression") {
+                    const nested = collectExpr(file, elseBody, moduleName);
+                    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, elseClause),
+                        children: collectExpr(file, elseBody, moduleName),
+                    });
+                }
+            }
+            if (cond)
+                walk(cond);
+            return;
+        }
+        if (n.type === "application_expression") {
+            const callee = n.namedChild(0);
+            if (callee) {
+                const key = valuePathKey(callee, moduleName);
+                if (key)
+                    addCall(key, n);
+            }
+            for (const child of namedChildren(n).slice(1))
+                walk(child);
+            return;
+        }
+        if (n.type === "sequence_expression") {
+            for (const child of namedChildren(n))
+                walk(child);
+            return;
+        }
+        for (const child of namedChildren(n))
+            walk(child);
+    };
+    walk(node);
+    return steps;
+}
+function bindingBody(binding) {
+    const kids = namedChildren(binding);
+    // skip value_name, parameters, type constraints
+    const body = [...kids]
+        .reverse()
+        .find((c) => c.type !== "value_name" &&
+        c.type !== "parameter" &&
+        c.type !== "type_constraint" &&
+        c.type !== "attribute") ?? null;
+    return body;
+}
+function handleLetBinding(file, binding, moduleName, functions) {
+    const name = childByType(binding, "value_name")?.text ?? null;
+    if (!name)
+        return;
+    // Only treat as function if it has parameters or is clearly a fun
+    const hasParams = namedChildren(binding).some((c) => c.type === "parameter");
+    const body = bindingBody(binding);
+    // `let f = fun x -> ...` is callable; any other binding without parameters is not.
+    if (!hasParams && body?.type !== "fun_expression")
+        return;
+    const key = moduleName ? `${moduleName}.${name}` : name;
+    const funBody = body?.type === "fun_expression"
+        ? bindingBody(body) ?? body.namedChild(body.namedChildCount - 1)
+        : body;
+    functions.push({
+        key,
+        label: `${key}${getParamsLabel(binding)}`,
+        file,
+        steps: collectExpr(file, funBody, moduleName),
+        exported: true,
+        start: binding.startIndex,
+        end: binding.endIndex,
+    });
+}
+function handleValueDefinition(file, node, moduleName, functions) {
+    for (const b of namedChildren(node)) {
+        if (b.type === "let_binding") {
+            handleLetBinding(file, b, moduleName, functions);
+        }
+    }
+}
+function handleModule(file, node, functions) {
+    const binding = childByType(node, "module_binding") ?? node;
+    const name = childByType(binding, "module_name")?.text ??
+        childByType(node, "module_name")?.text ??
+        null;
+    if (!name)
+        return;
+    const structure = childByType(binding, "structure") ?? childByType(node, "structure");
+    if (!structure)
+        return;
+    for (const item of namedChildren(structure)) {
+        if (item.type === "value_definition") {
+            handleValueDefinition(file, item, name, functions);
+        }
+        else if (item.type === "module_definition") {
+            // nested modules — prefix could be nested; skip deep nesting for prototype
+            handleModule(file, item, functions);
+        }
+    }
+}
+function extractFromTree(file, _source, tree) {
+    const functions = [];
+    for (const stmt of namedChildren(tree.rootNode)) {
+        if (stmt.type === "value_definition") {
+            handleValueDefinition(file, stmt, null, functions);
+        }
+        else if (stmt.type === "module_definition") {
+            handleModule(file, stmt, functions);
+        }
+    }
+    return functions;
+}
+export const ocamlExtractor = {
+    id: "ocaml",
+    extensions: [".ml"],
+    grammarPackage: "tree-sitter-ocaml",
+    grammarExport: "ocaml",
+    extract: extractFromTree,
+};

package/dist/languages/perl.d.ts

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