diffninja 0.1.0

package/dist/languages/grammars.js

@@ -0,0 +1,351 @@
+import { createRequire } from "node:module";
+import { execFileSync } from "node:child_process";
+import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync, writeFileSync, } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, isAbsolute, join } from "node:path";
+import { z } from "zod";
+function errnoCode(err) {
+    // SAFETY: Node require/fs failures are ErrnoException with optional string code.
+    return err.code;
+}
+/** On-disk cache of npm-installed tree-sitter grammar packages. */
+export function grammarCacheDir() {
+    const override = process.env.CALLDIFF_GRAMMAR_CACHE;
+    if (override)
+        return override;
+    return join(homedir(), ".cache", "calldiff", "grammars");
+}
+function packageInstalled(cacheDir, npmPackage) {
+    return existsSync(join(cacheDir, "node_modules", npmPackage));
+}
+const cacheManifestSchema = z
+    .object({ allowScripts: z.record(z.string(), z.unknown()).optional() })
+    .catchall(z.unknown());
+/**
+ * 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 function ensureCachePackageJson(cacheDir, npmPackage) {
+    mkdirSync(cacheDir, { recursive: true });
+    const pkgPath = join(cacheDir, "package.json");
+    let pkg = {
+        name: "calldiff-grammar-cache",
+        private: true,
+        description: "On-demand tree-sitter grammars for calldiff",
+    };
+    if (existsSync(pkgPath)) {
+        try {
+            const parsed = cacheManifestSchema.safeParse(JSON.parse(readFileSync(pkgPath, "utf8")));
+            if (parsed.success)
+                pkg = parsed.data;
+        }
+        catch {
+            // An unreadable cache manifest is replaced; the grammars beside it stay.
+        }
+    }
+    if (pkg.allowScripts?.[npmPackage] === true && existsSync(pkgPath))
+        return;
+    pkg.allowScripts = { ...pkg.allowScripts, [npmPackage]: true };
+    writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + "\n", "utf8");
+}
+/**
+ * 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 function npmCliPath(cli, directories = [
+    ...(process.env.PATH ?? "").split(";"),
+    dirname(process.execPath),
+]) {
+    for (const raw of directories) {
+        const directory = raw.trim().replace(/^"|"$/g, "");
+        // Never resolve executables from the repository being reviewed.
+        if (!isAbsolute(directory))
+            continue;
+        const path = join(directory, "node_modules", "npm", "bin", cli);
+        if (existsSync(path))
+            return path;
+    }
+    return 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 function npmSpawnSpec(args, platform = process.platform) {
+    if (platform !== "win32")
+        return { file: "npm", args };
+    const cli = npmCliPath("npm-cli.js");
+    if (cli === undefined) {
+        throw new Error("Cannot locate npm's npm-cli.js. Install Node.js with npm and add its directory to PATH.");
+    }
+    return { file: process.execPath, args: [cli, ...args] };
+}
+/**
+ * Some grammar packages (e.g. tree-sitter-c-sharp ≥0.23.5) ship ESM bindings
+ * with top-level await, which `require()` cannot load. Fall back to the native
+ * `.node` addon via node-gyp-build — same payload the JS wrapper would return.
+ */
+function loadNativeBinding(packageRoot) {
+    try {
+        const require = createRequire(join(packageRoot, "package.json"));
+        // SAFETY: node-gyp-build's default export is (root) => native binding.
+        const gypBuild = require("node-gyp-build");
+        const binding = gypBuild(packageRoot);
+        try {
+            binding.nodeTypeInfo = require(join(packageRoot, "src", "node-types.json"));
+        }
+        catch {
+            // optional metadata
+        }
+        return binding;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Expected native machine type for this host, for checking prebuild headers.
+ * ELF e_machine (Linux), Mach-O cputype (macOS), PE COFF machine (Windows).
+ */
+function expectedMachine() {
+    if (process.platform === "linux") {
+        return process.arch === "x64" ? 62 : process.arch === "arm64" ? 183 : null;
+    }
+    if (process.platform === "darwin") {
+        return process.arch === "x64"
+            ? 0x01000007
+            : process.arch === "arm64"
+                ? 0x0100000c
+                : null;
+    }
+    if (process.platform === "win32") {
+        return process.arch === "x64" ? 0x8664 : process.arch === "arm64" ? 0xaa64 : null;
+    }
+    return null;
+}
+/** Machine type declared in a native prebuild's header, or null if unreadable. */
+function prebuildMachine(prebuildPath) {
+    let header;
+    try {
+        header = readFileSync(prebuildPath).subarray(0, 64);
+    }
+    catch {
+        return null;
+    }
+    if (header.length < 20)
+        return null;
+    // ELF: 7f 45 4c 46, e_machine is a little-endian u16 at offset 18.
+    if (header[0] === 0x7f && header[1] === 0x45 && header[2] === 0x4c && header[3] === 0x46) {
+        return header.readUInt16LE(18);
+    }
+    // Mach-O 64-bit: FE ED FA CF (little-endian), cputype is a u32 at offset 4.
+    if (header[0] === 0xcf &&
+        header[1] === 0xfa &&
+        header[2] === 0xed &&
+        header[3] === 0xfe) {
+        return header.readUInt32LE(4);
+    }
+    // PE: 4D 5A ("MZ"), e_lfanew at 0x3C points at the COFF header whose first
+    // u16 is the machine type.
+    if (header[0] === 0x4d && header[1] === 0x5a) {
+        const peOffset = header.readUInt32LE(0x3c);
+        if (peOffset + 2 <= header.length)
+            return header.readUInt16LE(peOffset);
+    }
+    return null;
+}
+/**
+ * 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 function mislabeledPrebuild(packageRoot) {
+    const expected = expectedMachine();
+    if (expected === null)
+        return null;
+    let entries;
+    try {
+        entries = readdirSync(join(packageRoot, "prebuilds", `${process.platform}-${process.arch}`), {
+            withFileTypes: true,
+        });
+    }
+    catch {
+        return null;
+    }
+    for (const entry of entries) {
+        if (!entry.isFile() || !entry.name.endsWith(".node"))
+            continue;
+        const full = join(packageRoot, "prebuilds", `${process.platform}-${process.arch}`, entry.name);
+        const machine = prebuildMachine(full);
+        if (machine !== null && machine !== expected)
+            return full;
+    }
+    return null;
+}
+/**
+ * Explain a native load failure in actionable terms. Extraction treats load
+ * failures as per-file warnings, so the hint must name the fix.
+ */
+function withNativeLoadHints(npmPackage, err) {
+    if (/GLIBCXX|GLIBC_/i.test(err.message)) {
+        return (`${err.message} — the ${npmPackage} native module needs libstdc++ from GCC 13.1 ` +
+            `or newer (for example Ubuntu 24.04+). Rebuild it for this host with ` +
+            `\`npm rebuild ${npmPackage} --build-from-source\`, or upgrade libstdc++.`);
+    }
+    return err.message;
+}
+function requireGrammar(require, npmPackage, packageRoot) {
+    try {
+        // SAFETY: grammar packages export a module compatible with GrammarModule.
+        return require(npmPackage);
+    }
+    catch (err) {
+        // SAFETY: catch bindings are unknown; normalize to Error at the boundary.
+        const failure = err instanceof Error ? err : new Error(String(err));
+        const code = errnoCode(failure);
+        if (code === "ERR_REQUIRE_ASYNC_MODULE" ||
+            failure.message.includes("top-level await")) {
+            const binding = loadNativeBinding(packageRoot);
+            if (binding)
+                return binding;
+        }
+        else {
+            // A mislabeled prebuild blocks node-gyp-build's own source-build
+            // fallback. This directory is diffninja's own grammar cache, so remove
+            // the bad artifact and let the load retry compile from source.
+            const bad = mislabeledPrebuild(packageRoot);
+            if (bad !== null) {
+                rmSync(bad, { force: true });
+                try {
+                    // SAFETY: grammar packages export a module compatible with GrammarModule.
+                    return require(npmPackage);
+                }
+                catch {
+                    const binding = loadNativeBinding(packageRoot);
+                    if (binding)
+                        return binding;
+                }
+            }
+        }
+        throw new Error(withNativeLoadHints(npmPackage, failure));
+    }
+}
+function installSpecFor(npmPackage) {
+    switch (npmPackage) {
+        case "tree-sitter-c-sharp":
+            return "tree-sitter-c-sharp@0.23.1";
+        case "@tree-sitter-grammars/tree-sitter-lua":
+            // 0.4+ is ESM-with-TLA; 0.2.0 is CJS and loads via createRequire.
+            return "@tree-sitter-grammars/tree-sitter-lua@0.2.0";
+        default:
+            return npmPackage;
+    }
+}
+function sleepMs(ms) {
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
+/** Why this grammar's install can fail beyond npm itself, for the error text. */
+function installFailureHint(npmPackage) {
+    if (npmPackage === "tree-sitter-swift") {
+        return ("tree-sitter-swift downloads its parser CLI from GitHub Releases during " +
+            "install; a proxy or offline network fails that download. Retry with " +
+            "network access to github.com, or pre-populate CALLDIFF_GRAMMAR_CACHE.");
+    }
+    if (npmPackage === "tree-sitter-perl" || npmPackage === "tree-sitter-kotlin") {
+        return ("this grammar ships no prebuilt binary and compiles from source: Python " +
+            "and a C/C++ toolchain (build-essential, Xcode command line tools, or " +
+            "Visual Studio Build Tools) are required.");
+    }
+    return null;
+}
+/**
+ * Install an on-demand grammar into the cache, retrying transient network
+ * failures (the Swift parser CLI download is the known flaky one). Throws an
+ * actionable error when the install cannot succeed.
+ */
+function installGrammarPackage(cacheDir, npmPackage) {
+    const npm = npmSpawnSpec([
+        "install",
+        "--prefix",
+        cacheDir,
+        "--no-save",
+        "--no-fund",
+        "--no-audit",
+        "--legacy-peer-deps",
+        installSpecFor(npmPackage),
+    ]);
+    for (let attempt = 1; attempt <= 3; attempt++) {
+        try {
+            execFileSync(npm.file, npm.args, {
+                stdio: ["ignore", "pipe", "pipe"],
+                env: process.env,
+                timeout: 300_000,
+            });
+            return;
+        }
+        catch (err) {
+            if (attempt === 3) {
+                // SAFETY: catch bindings are unknown; normalize to Error at the boundary.
+                const failure = err instanceof Error ? err : new Error(String(err));
+                const hint = installFailureHint(npmPackage);
+                throw new Error(`Could not install the ${npmPackage} grammar into ${cacheDir}: ${failure.message}` +
+                    (hint ? ` ${hint}` : ""));
+            }
+            sleepMs(2000 * attempt);
+        }
+    }
+}
+/**
+ * Install an npm grammar package into the shared cache if missing, then require it.
+ * Reuses the cache across CLI invocations.
+ */
+export function loadGrammarPackage(npmPackage) {
+    // Prefer the app's own dependency when present (e.g. tree-sitter-typescript).
+    try {
+        const localRequire = createRequire(import.meta.url);
+        try {
+            // SAFETY: local dependency resolves to a tree-sitter grammar module.
+            return localRequire(npmPackage);
+        }
+        catch (err) {
+            // SAFETY: catch bindings are unknown; normalize to Error at the boundary.
+            const failure = err instanceof Error ? err : new Error(String(err));
+            const code = errnoCode(failure);
+            if (code === "ERR_REQUIRE_ASYNC_MODULE" ||
+                failure.message.includes("top-level await")) {
+                const entry = localRequire.resolve(npmPackage);
+                const packageRoot = join(entry, "..", "..");
+                const binding = loadNativeBinding(packageRoot);
+                if (binding)
+                    return binding;
+            }
+            throw err;
+        }
+    }
+    catch {
+        // fall through to cache
+    }
+    const cacheDir = grammarCacheDir();
+    if (!packageInstalled(cacheDir, npmPackage)) {
+        ensureCachePackageJson(cacheDir, npmPackage);
+        installGrammarPackage(cacheDir, npmPackage);
+    }
+    const require = createRequire(join(cacheDir, "package.json"));
+    const packageRoot = join(cacheDir, "node_modules", npmPackage);
+    return requireGrammar(require, npmPackage, packageRoot);
+}
+/** Resolve the value to pass to parser.setLanguage. */
+export function resolveLanguage(mod, exportName) {
+    if (exportName) {
+        const named = mod[exportName];
+        if (named != null)
+            return named;
+    }
+    // Native grammar packages export { language, nodeTypeInfo, ... } — pass the module.
+    return mod;
+}

package/dist/languages/haskell.d.ts

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

package/dist/languages/haskell.js

@@ -0,0 +1,250 @@
+import { heuristicCallSyntax } from "./call-syntax.js";
+import { childByType, collapseWs, locFromNode, namedChildren, } from "./types.js";
+function isLikelyTypeName(name) {
+    const c = name[0];
+    return c !== undefined && c === c.toUpperCase() && c !== c.toLowerCase();
+}
+function patternNames(patterns) {
+    if (!patterns)
+        return [];
+    const names = [];
+    for (const p of namedChildren(patterns)) {
+        if (p.type === "variable")
+            names.push(p.text);
+        else if (p.type === "wildcard")
+            names.push("_");
+        else
+            names.push("_");
+    }
+    return names;
+}
+function getParamsLabel(patterns) {
+    const names = patternNames(patterns);
+    return names.length === 0 ? "()" : `(${names.join(", ")})`;
+}
+function calleeFromExp(node) {
+    if (node.type === "variable") {
+        if (node.text === "return" || node.text === "pure")
+            return null;
+        return node.text;
+    }
+    if (node.type === "apply") {
+        // f x y → callee is leftmost function
+        const head = node.namedChild(0);
+        if (!head)
+            return null;
+        return calleeFromExp(head);
+    }
+    if (node.type === "parens") {
+        const inner = node.namedChild(0);
+        return inner ? calleeFromExp(inner) : null;
+    }
+    if (node.type === "qualified") {
+        // M.f
+        const kids = namedChildren(node);
+        const mod = kids.find((c) => c.type === "module" || c.type === "module_id");
+        const vari = kids.find((c) => c.type === "variable");
+        if (vari && mod) {
+            const modName = mod.type === "module"
+                ? (childByType(mod, "module_id")?.text ?? mod.text.replace(/\.$/, ""))
+                : mod.text.replace(/\.$/, "");
+            return `${modName}.${vari.text}`;
+        }
+        if (vari)
+            return vari.text;
+    }
+    // constructors / operators / literals — ignore as callees when not useful
+    if (node.type === "constructor" || node.type === "operator")
+        return null;
+    if (node.type === "literal" || node.type === "unit")
+        return null;
+    return null;
+}
+function collectFromMatch(file, match) {
+    if (!match)
+        return [];
+    const body = match.namedChild(0) ?? namedChildren(match)[0] ?? null;
+    if (!body)
+        return [];
+    return collectExpr(file, body);
+}
+function collectExpr(file, node) {
+    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 binds / lambdas / local functions
+        if (n.type === "function" ||
+            n.type === "bind" ||
+            n.type === "lambda" ||
+            n.type === "local_binds" ||
+            n.type === "declarations") {
+            return;
+        }
+        if (n.type === "conditional") {
+            const kids = namedChildren(n);
+            const cond = kids[0] ?? null;
+            const thenE = kids[1] ?? null;
+            const elseE = kids[2] ?? 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: thenE ? collectExpr(file, thenE) : [],
+            });
+            if (elseE) {
+                steps.push({
+                    type: "branch",
+                    key: "else",
+                    label: "else",
+                    ...locFromNode(file, elseE),
+                    children: collectExpr(file, elseE),
+                });
+            }
+            return;
+        }
+        if (n.type === "case") {
+            const alts = childByType(n, "alternatives");
+            for (const alt of alts ? namedChildren(alts) : []) {
+                if (alt.type !== "alternative")
+                    continue;
+                const pattern = namedChildren(alt).find((c) => c.type !== "match") ?? null;
+                const text = pattern ? collapseWs(pattern.text) : "";
+                const match = childByType(alt, "match");
+                steps.push({
+                    type: "branch",
+                    key: text ? `case:${text}` : "case",
+                    label: text ? `case ${text}` : "case",
+                    ...locFromNode(file, pattern ?? alt),
+                    children: collectFromMatch(file, match),
+                });
+            }
+            return;
+        }
+        if (n.type === "apply") {
+            const key = calleeFromExp(n);
+            // Skip type-like constructors: Just x, Runner
+            if (key && !isLikelyTypeName(key.split(".").pop() ?? key)) {
+                addCall(key, n);
+            }
+            // Walk argument expressions for nested applies, but not bare variable args
+            for (const child of namedChildren(n).slice(1)) {
+                if (child.type === "variable" || child.type === "literal" || child.type === "unit") {
+                    continue;
+                }
+                if (child.type === "parens") {
+                    const inner = child.namedChild(0);
+                    if (inner)
+                        walk(inner);
+                    continue;
+                }
+                walk(child);
+            }
+            return;
+        }
+        if (n.type === "variable") {
+            // Bare variable used as expression in do-block is a call-ish nullary
+            if (n.text !== "return" && n.text !== "pure" && !isLikelyTypeName(n.text)) {
+                addCall(n.text, n);
+            }
+            return;
+        }
+        if (n.type === "qualified") {
+            const key = calleeFromExp(n);
+            if (key && !isLikelyTypeName(key.split(".").pop() ?? key)) {
+                addCall(key, n);
+            }
+            return;
+        }
+        if (n.type === "infix") {
+            for (const child of namedChildren(n)) {
+                if (child.type === "operator")
+                    continue;
+                walk(child);
+            }
+            return;
+        }
+        if (n.type === "do") {
+            for (const child of namedChildren(n)) {
+                if (child.type === "exp") {
+                    const inner = child.namedChild(0) ?? child;
+                    walk(inner);
+                }
+                else {
+                    walk(child);
+                }
+            }
+            return;
+        }
+        // Conditionals already handled; avoid double-counting by not
+        // falling through into then/else when somehow re-entered.
+        for (const child of namedChildren(n))
+            walk(child);
+    };
+    walk(node);
+    return steps;
+}
+function handleFunctionOrBind(file, node, functions) {
+    const name = childByType(node, "variable")?.text ??
+        namedChildren(node).find((c) => c.type === "variable")?.text ??
+        null;
+    if (!name)
+        return;
+    // Skip type signatures mistakenly matched — signatures use `signature` type
+    const patterns = childByType(node, "patterns");
+    const match = childByType(node, "match");
+    functions.push({
+        key: name,
+        label: `${name}${getParamsLabel(patterns)}`,
+        file,
+        steps: collectFromMatch(file, match),
+        exported: true,
+        start: node.startIndex,
+        end: node.endIndex,
+    });
+}
+function visitDecls(file, decls, functions) {
+    for (const d of namedChildren(decls)) {
+        if (d.type === "function" || d.type === "bind") {
+            // `function` nodes also appear inside signatures — only top-level with match
+            if (childByType(d, "match") || d.type === "bind") {
+                handleFunctionOrBind(file, d, functions);
+            }
+        }
+    }
+}
+function extractFromTree(file, _source, tree) {
+    const functions = [];
+    const root = tree.rootNode;
+    // haskell → declarations, or header + declarations
+    for (const child of namedChildren(root)) {
+        if (child.type === "declarations") {
+            visitDecls(file, child, functions);
+        }
+    }
+    // Some files may root directly under declarations-less structure
+    if (functions.length === 0) {
+        for (const child of namedChildren(root)) {
+            if (child.type === "function" || child.type === "bind") {
+                handleFunctionOrBind(file, child, functions);
+            }
+        }
+    }
+    return functions;
+}
+export const haskellExtractor = {
+    id: "haskell",
+    extensions: [".hs"],
+    grammarPackage: "tree-sitter-haskell",
+    extract: extractFromTree,
+};

package/dist/languages/java.d.ts

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