diffninja 0.1.0

package/dist/git.d.ts

@@ -0,0 +1,40 @@
+import type { Snapshot, SnapshotPair, SnapshotPairWithPaths, SnapshotWithPaths } from "./types.js";
+export declare function assertGitRepo(cwd: string): void;
+export declare function resolveSnapshots(from: string | undefined, to: string | undefined): SnapshotPair;
+/**
+ * Resolve diff from/to/paths with git-diff defaults, treating on-disk path
+ * positionals as path filters when they are not valid git refs.
+ *
+ * Examples:
+ * - `diff main src` → main vs worktree, paths=[src]
+ * - `diff main feature src` → main vs feature, paths=[src]
+ * - `diff src` → HEAD vs worktree, paths=[src]
+ */
+export declare function resolveDiffSnapshotsAndPaths(cwd: string, from: string | undefined, to: string | undefined, paths: string[]): SnapshotPairWithPaths;
+/** Single snapshot for `calldiff tree` / `reach` — no ref → working tree. */
+export declare function resolveSnapshot(ref: string | undefined): Snapshot;
+/**
+ * Resolve optional ref + path filters for tree/reach.
+ * A lone positional that isn't a git ref but exists on disk is treated as a
+ * path filter on the working tree (`calldiff tree -e foo src/lib`).
+ */
+export declare function resolveSnapshotAndPaths(cwd: string, ref: string | undefined, paths: string[]): SnapshotWithPaths;
+export declare function verifyCommit(cwd: string, ref: string): void;
+export interface SnapshotFile {
+    path: string;
+    /** Git blob metadata. Worktree files do not have it. */
+    oid?: string;
+    size?: number;
+}
+export declare function listSnapshotFiles(cwd: string, snapshot: Snapshot, pathFilters?: string[]): SnapshotFile[];
+export declare function visitCommitBlobs(cwd: string, files: SnapshotFile[], visit: (oid: string, source: string) => void): void;
+export declare function visitWorktreeFiles(cwd: string, files: SnapshotFile[], visit: (file: SnapshotFile, source: string) => void): void;
+export declare function describeSnapshot(snapshot: Snapshot): string;
+/**
+ * Read one file from a snapshot, or null when it does not exist there.
+ *
+ * A commit is read through git, so the text is the immutable blob the revision
+ * recorded even when the worktree has moved on. A worktree snapshot reads the
+ * file on disk.
+ */
+export declare function readSnapshotFile(cwd: string, snapshot: Snapshot, path: string): string | null;

package/dist/git.js

@@ -0,0 +1,288 @@
+import { execFileSync } from "node:child_process";
+import { existsSync, lstatSync, readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { listSupportedExtensions } from "./languages/registry.js";
+function gitBuffer(cwd, args, input, maxBuffer = 64 * 1024 * 1024) {
+    return execFileSync("git", ["--no-replace-objects", ...args], {
+        cwd,
+        input,
+        maxBuffer,
+        stdio: ["pipe", "pipe", "pipe"],
+    });
+}
+function git(cwd, args) {
+    return gitBuffer(cwd, args).toString("utf8");
+}
+export function assertGitRepo(cwd) {
+    try {
+        git(cwd, ["rev-parse", "--is-inside-work-tree"]);
+    }
+    catch {
+        throw new Error(`Not a git repository: ${cwd}`);
+    }
+}
+export function resolveSnapshots(from, to) {
+    // git-diff defaults: no args → HEAD vs worktree; one arg → that vs worktree
+    const left = {
+        kind: "commit",
+        ref: from ?? "HEAD",
+    };
+    const right = to === undefined
+        ? { kind: "worktree", ref: "WORKTREE" }
+        : { kind: "commit", ref: to };
+    return { from: left, to: right };
+}
+function isCommitRef(cwd, ref) {
+    try {
+        git(cwd, ["rev-parse", "--verify", `${ref}^{commit}`]);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function isPathOnDisk(cwd, value) {
+    return existsSync(resolve(cwd, value));
+}
+/**
+ * Resolve diff from/to/paths with git-diff defaults, treating on-disk path
+ * positionals as path filters when they are not valid git refs.
+ *
+ * Examples:
+ * - `diff main src` → main vs worktree, paths=[src]
+ * - `diff main feature src` → main vs feature, paths=[src]
+ * - `diff src` → HEAD vs worktree, paths=[src]
+ */
+export function resolveDiffSnapshotsAndPaths(cwd, from, to, paths) {
+    if (from === undefined && to === undefined) {
+        return { ...resolveSnapshots(undefined, undefined), paths };
+    }
+    if (from !== undefined && to === undefined) {
+        if (isCommitRef(cwd, from)) {
+            return { ...resolveSnapshots(from, undefined), paths };
+        }
+        if (isPathOnDisk(cwd, from)) {
+            return { ...resolveSnapshots(undefined, undefined), paths: [from, ...paths] };
+        }
+        throw new Error(`Unknown git ref: ${from}`);
+    }
+    if (from !== undefined && to !== undefined) {
+        if (!isCommitRef(cwd, from)) {
+            throw new Error(`Unknown git ref: ${from}`);
+        }
+        if (isCommitRef(cwd, to)) {
+            return { ...resolveSnapshots(from, to), paths };
+        }
+        if (isPathOnDisk(cwd, to)) {
+            return {
+                ...resolveSnapshots(from, undefined),
+                paths: [to, ...paths],
+            };
+        }
+        throw new Error(`Unknown git ref: ${to}`);
+    }
+    // to without from shouldn't happen via CLI positionals, but honor options.
+    return { ...resolveSnapshots(from, to), paths };
+}
+/** Single snapshot for `calldiff tree` / `reach` — no ref → working tree. */
+export function resolveSnapshot(ref) {
+    if (ref === undefined) {
+        return { kind: "worktree", ref: "WORKTREE" };
+    }
+    return { kind: "commit", ref };
+}
+/**
+ * Resolve optional ref + path filters for tree/reach.
+ * A lone positional that isn't a git ref but exists on disk is treated as a
+ * path filter on the working tree (`calldiff tree -e foo src/lib`).
+ */
+export function resolveSnapshotAndPaths(cwd, ref, paths) {
+    if (ref === undefined) {
+        return { snapshot: resolveSnapshot(undefined), paths };
+    }
+    if (isCommitRef(cwd, ref)) {
+        return { snapshot: resolveSnapshot(ref), paths };
+    }
+    if (isPathOnDisk(cwd, ref)) {
+        return {
+            snapshot: resolveSnapshot(undefined),
+            paths: [ref, ...paths],
+        };
+    }
+    throw new Error(`Unknown git ref: ${ref}`);
+}
+export function verifyCommit(cwd, ref) {
+    if (!isCommitRef(cwd, ref)) {
+        throw new Error(`Unknown git ref: ${ref}`);
+    }
+}
+const SOURCE_EXT = new Set(listSupportedExtensions());
+function isSourceFile(path) {
+    const lower = path.toLowerCase();
+    if (lower.endsWith(".d.ts"))
+        return false;
+    const dot = lower.lastIndexOf(".");
+    if (dot < 0)
+        return false;
+    return SOURCE_EXT.has(lower.slice(dot));
+}
+function isRegularFile(path) {
+    try {
+        return lstatSync(path).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+function listWorktreeFiles(cwd) {
+    const output = git(cwd, [
+        "ls-files",
+        "-z",
+        "--cached",
+        "--others",
+        "--exclude-standard",
+    ]);
+    return output
+        .split("\0")
+        .filter((path) => path && isSourceFile(path) && isRegularFile(resolve(cwd, path)))
+        .map((path) => ({ path }));
+}
+function listCommitFiles(cwd, ref) {
+    const output = git(cwd, ["ls-tree", "-r", "-z", "-l", ref]);
+    const files = [];
+    for (const record of output.split("\0")) {
+        if (!record)
+            continue;
+        const tab = record.indexOf("\t");
+        if (tab < 0)
+            continue;
+        const [mode, type, oid, sizeText] = record
+            .slice(0, tab)
+            .trim()
+            .split(/\s+/);
+        const path = record.slice(tab + 1);
+        const regular = mode === "100644" || mode === "100755";
+        const size = Number(sizeText);
+        if (regular &&
+            type === "blob" &&
+            oid &&
+            Number.isInteger(size) &&
+            isSourceFile(path)) {
+            files.push({ path, oid, size });
+        }
+    }
+    return files;
+}
+function pathAllowed(file, pathFilters) {
+    if (pathFilters.length === 0)
+        return true;
+    return pathFilters.some((filter) => {
+        const normalized = filter.replace(/^\.\//, "").replace(/\/$/, "");
+        return (file === normalized ||
+            file.startsWith(`${normalized}/`) ||
+            file.endsWith(normalized));
+    });
+}
+export function listSnapshotFiles(cwd, snapshot, pathFilters = []) {
+    const files = snapshot.kind === "worktree"
+        ? listWorktreeFiles(cwd)
+        : listCommitFiles(cwd, snapshot.ref);
+    return files
+        .filter((file) => pathAllowed(file.path, pathFilters))
+        .sort((a, b) => a.path.localeCompare(b.path));
+}
+const BATCH_BYTES = 32 * 1024 * 1024;
+function chunkBlobs(files) {
+    const unique = new Map();
+    for (const file of files) {
+        if (file.oid && file.size !== undefined && !unique.has(file.oid)) {
+            unique.set(file.oid, file.size);
+        }
+    }
+    const chunks = [];
+    let chunk = [];
+    let bytes = 0;
+    for (const [oid, size] of unique) {
+        if (chunk.length > 0 && bytes + size > BATCH_BYTES) {
+            chunks.push(chunk);
+            chunk = [];
+            bytes = 0;
+        }
+        chunk.push({ oid, size });
+        bytes += size;
+    }
+    if (chunk.length > 0)
+        chunks.push(chunk);
+    return chunks;
+}
+function readBlobBatch(cwd, batch) {
+    const input = Buffer.from(`${batch.map((blob) => blob.oid).join("\n")}\n`);
+    const bytes = batch.reduce((total, blob) => total + blob.size, 0);
+    const maxBuffer = bytes + batch.length * 128 + 1024;
+    const output = gitBuffer(cwd, ["cat-file", "--batch"], input, maxBuffer);
+    const blobs = new Map();
+    let offset = 0;
+    while (offset < output.length) {
+        const headerEnd = output.indexOf(0x0a, offset);
+        if (headerEnd < 0)
+            throw new Error("Invalid git cat-file response");
+        const header = output.subarray(offset, headerEnd).toString("ascii");
+        const [oid, type, sizeText] = header.split(" ");
+        const size = Number(sizeText);
+        if (!oid || type !== "blob" || !Number.isInteger(size)) {
+            throw new Error(`Invalid git cat-file header: ${header}`);
+        }
+        const contentStart = headerEnd + 1;
+        const contentEnd = contentStart + size;
+        if (contentEnd >= output.length) {
+            throw new Error(`Truncated git blob: ${oid}`);
+        }
+        blobs.set(oid, output.subarray(contentStart, contentEnd).toString("utf8"));
+        offset = contentEnd + 1;
+    }
+    return blobs;
+}
+export function visitCommitBlobs(cwd, files, visit) {
+    for (const batch of chunkBlobs(files)) {
+        for (const [oid, source] of readBlobBatch(cwd, batch)) {
+            visit(oid, source);
+        }
+    }
+}
+export function visitWorktreeFiles(cwd, files, visit) {
+    for (const file of files) {
+        const full = resolve(cwd, file.path);
+        if (!isRegularFile(full))
+            continue;
+        visit(file, readFileSync(full, "utf8"));
+    }
+}
+export function describeSnapshot(snapshot) {
+    return snapshot.kind === "worktree" ? "working tree" : snapshot.ref;
+}
+/**
+ * Read one file from a snapshot, or null when it does not exist there.
+ *
+ * A commit is read through git, so the text is the immutable blob the revision
+ * recorded even when the worktree has moved on. A worktree snapshot reads the
+ * file on disk.
+ */
+export function readSnapshotFile(cwd, snapshot, path) {
+    if (snapshot.kind === "worktree") {
+        const full = resolve(cwd, path);
+        if (!isRegularFile(full))
+            return null;
+        try {
+            return readFileSync(full, "utf8");
+        }
+        catch {
+            return null;
+        }
+    }
+    try {
+        return git(cwd, ["show", `${snapshot.ref}:${path}`]);
+    }
+    catch {
+        return null;
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+export { cli, normalizeArgv } from "./cli.js";
+export { buildCallTree, exportsInFile, matchEntrypointFiles, normalizeEntryPath, resolveAllEntries, resolveEntry, resolveEntrypointFile, resolveFileEntrypoints, } from "./calltree.js";
+export { diffTrees, treeHasChanges } from "./diff.js";
+export { allFunctions, buildIndex, definitionsInFile, extractFunctions, } from "./extract.js";
+export { formatSourceLoc, pickLoc } from "./loc.js";
+export { collectPathsTo, findReachPaths, pathToTree } from "./reach.js";
+export { renderDiff, renderTree } from "./render.js";
+export { runDiff, runReach, runTree } from "./run.js";
+export type * from "./types.js";

package/dist/index.js

@@ -0,0 +1,8 @@
+export { cli, normalizeArgv } from "./cli.js";
+export { buildCallTree, exportsInFile, matchEntrypointFiles, normalizeEntryPath, resolveAllEntries, resolveEntry, resolveEntrypointFile, resolveFileEntrypoints, } from "./calltree.js";
+export { diffTrees, treeHasChanges } from "./diff.js";
+export { allFunctions, buildIndex, definitionsInFile, extractFunctions, } from "./extract.js";
+export { formatSourceLoc, pickLoc } from "./loc.js";
+export { collectPathsTo, findReachPaths, pathToTree } from "./reach.js";
+export { renderDiff, renderTree } from "./render.js";
+export { runDiff, runReach, runTree } from "./run.js";

package/dist/infer.d.ts

@@ -0,0 +1,21 @@
+import type { FunctionIndex } from "./extract.js";
+import type { DiffNode, FunctionInfo } from "./types.js";
+/**
+ * Infer entrypoints: exported functions whose expanded call trees differ,
+ * plus any explicitly requested symbol entries.
+ */
+export declare function inferEntries(before: FunctionIndex, after: FunctionIndex, explicit: string[], maxDepth: number): string[];
+export type ExplicitDiffEntry = {
+    key: string;
+    beforeInfo?: FunctionInfo;
+    afterInfo?: FunctionInfo;
+    /** When set, trees are built from these file-pinned definitions. */
+    file?: string;
+};
+/**
+ * Expand explicit `-e` symbols and `--file` paths into concrete diff roots.
+ */
+export declare function resolveExplicitDiffEntries(before: FunctionIndex, after: FunctionIndex, symbols: string[], files?: string[]): ExplicitDiffEntry[];
+export declare function diffEntry(key: string, before: FunctionIndex, after: FunctionIndex, maxDepth: number): DiffNode | null;
+/** Diff two file-pinned definitions (or missing on one side). */
+export declare function diffPinnedEntry(key: string, beforeInfo: FunctionInfo | undefined, afterInfo: FunctionInfo | undefined, before: FunctionIndex, after: FunctionIndex, maxDepth: number): DiffNode | null;

package/dist/infer.js

@@ -0,0 +1,189 @@
+import { allFunctions, flattenCallKeys } from "./extract.js";
+import { buildCallTree, buildCallTreeFromInfo, exportsInFile, indexedFiles, resolveEntry, resolveEntrypointFile, } from "./calltree.js";
+import { diffTrees, treeHasChanges } from "./diff.js";
+function emptyCallTree(key, label) {
+    return { key, label, children: [] };
+}
+function functionFingerprint(fn) {
+    if (!fn)
+        return null;
+    return JSON.stringify({ label: fn.label, steps: fn.steps });
+}
+function addReverseEdges(reverse, index) {
+    for (const [caller, fn] of index) {
+        for (const callee of flattenCallKeys(fn.steps)) {
+            let callers = reverse.get(callee);
+            if (!callers) {
+                callers = new Set();
+                reverse.set(callee, callers);
+            }
+            callers.add(caller);
+        }
+    }
+}
+function findAffected(before, after, maxDepth) {
+    const keys = new Set([...before.keys(), ...after.keys()]);
+    const reverse = new Map();
+    addReverseEdges(reverse, before);
+    addReverseEdges(reverse, after);
+    const distance = new Map();
+    const queue = [];
+    for (const key of keys) {
+        if (functionFingerprint(before.get(key)) === functionFingerprint(after.get(key))) {
+            continue;
+        }
+        distance.set(key, 0);
+        queue.push(key);
+    }
+    for (let i = 0; i < queue.length; i += 1) {
+        const callee = queue[i];
+        const nextDistance = distance.get(callee) + 1;
+        if (nextDistance > maxDepth)
+            continue;
+        for (const caller of reverse.get(callee) ?? []) {
+            const previous = distance.get(caller);
+            if (previous !== undefined && previous <= nextDistance)
+                continue;
+            distance.set(caller, nextDistance);
+            queue.push(caller);
+        }
+    }
+    return new Set(distance.keys());
+}
+function changedKeys(keys, before, after, maxDepth) {
+    return keys
+        .filter((key) => diffEntry(key, before, after, maxDepth) !== null)
+        .sort((a, b) => a.localeCompare(b));
+}
+/**
+ * Infer entrypoints: exported functions whose expanded call trees differ,
+ * plus any explicitly requested symbol entries.
+ */
+export function inferEntries(before, after, explicit, maxDepth) {
+    if (explicit.length > 0) {
+        const entries = [];
+        for (const entry of explicit) {
+            const key = resolveEntry(entry, after) ?? resolveEntry(entry, before);
+            if (!key)
+                throw new Error(`Entrypoint not found: ${entry}`);
+            if (!entries.includes(key))
+                entries.push(key);
+        }
+        return entries;
+    }
+    const affected = [...findAffected(before, after, maxDepth)].filter((key) => !key.startsWith("new "));
+    const exported = affected.filter((key) => Boolean(before.get(key)?.exported || after.get(key)?.exported));
+    const entries = changedKeys(exported, before, after, maxDepth);
+    if (entries.length > 0)
+        return entries;
+    const checked = new Set(exported);
+    const fallback = affected.filter((key) => !checked.has(key));
+    return changedKeys(fallback, before, after, maxDepth);
+}
+/**
+ * Expand explicit `-e` symbols and `--file` paths into concrete diff roots.
+ */
+export function resolveExplicitDiffEntries(before, after, symbols, files = []) {
+    const out = [];
+    const seen = new Set();
+    for (const entry of symbols) {
+        const key = resolveEntry(entry, after) ?? resolveEntry(entry, before);
+        if (!key)
+            throw new Error(`Entrypoint not found: ${entry}`);
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        out.push({ key });
+    }
+    for (const entry of files) {
+        const file = resolveEntrypointFile(entry, [
+            ...indexedFiles(before),
+            ...indexedFiles(after),
+        ]);
+        const keys = [
+            ...new Set([
+                ...exportsInFile(file, before),
+                ...exportsInFile(file, after),
+            ].map((info) => info.key)),
+        ].sort((a, b) => a.localeCompare(b));
+        if (keys.length === 0) {
+            throw new Error(`No exported entrypoints in ${file}`);
+        }
+        for (const key of keys) {
+            const id = `${file}\0${key}`;
+            if (seen.has(id))
+                continue;
+            seen.add(id);
+            const beforeInfo = allFunctions(before).find((fn) => fn.file === file && fn.key === key && fn.exported);
+            const afterInfo = allFunctions(after).find((fn) => fn.file === file && fn.key === key && fn.exported);
+            out.push({ key, beforeInfo, afterInfo, file });
+        }
+    }
+    return out;
+}
+export function diffEntry(key, before, after, maxDepth) {
+    const beforeKey = resolveEntry(key, before) ?? key;
+    const afterKey = resolveEntry(key, after) ?? key;
+    const hasBefore = before.has(beforeKey);
+    const hasAfter = after.has(afterKey);
+    if (!hasBefore && !hasAfter)
+        return null;
+    const beforeTree = hasBefore
+        ? buildCallTree(beforeKey, before, maxDepth)
+        : emptyCallTree(afterKey, after.get(afterKey)?.label ?? afterKey);
+    const afterTree = hasAfter
+        ? buildCallTree(afterKey, after, maxDepth)
+        : emptyCallTree(beforeKey, before.get(beforeKey)?.label ?? beforeKey);
+    if (!hasBefore && hasAfter) {
+        const diff = diffTrees({ key: afterKey, label: afterTree.label, children: [] }, afterTree);
+        return { ...diff, status: "added" };
+    }
+    if (hasBefore && !hasAfter) {
+        const diff = diffTrees(beforeTree, {
+            key: beforeKey,
+            label: beforeTree.label,
+            children: [],
+        });
+        // The after side is a stub with no definition; the removed root is still a
+        // definition in the before snapshot, so keep it for source lookups.
+        diff.status = "removed";
+        if (beforeTree.definition)
+            diff.definition = beforeTree.definition;
+        return diff;
+    }
+    const diff = diffTrees(beforeTree, afterTree);
+    if (!treeHasChanges(diff))
+        return null;
+    return diff;
+}
+/** Diff two file-pinned definitions (or missing on one side). */
+export function diffPinnedEntry(key, beforeInfo, afterInfo, before, after, maxDepth) {
+    if (!beforeInfo && !afterInfo)
+        return null;
+    const beforeTree = beforeInfo
+        ? buildCallTreeFromInfo(beforeInfo, before, maxDepth)
+        : emptyCallTree(key, afterInfo?.label ?? key);
+    const afterTree = afterInfo
+        ? buildCallTreeFromInfo(afterInfo, after, maxDepth)
+        : emptyCallTree(key, beforeInfo?.label ?? key);
+    if (!beforeInfo && afterInfo) {
+        const diff = diffTrees({ key, label: afterTree.label, children: [] }, afterTree);
+        return { ...diff, status: "added" };
+    }
+    if (beforeInfo && !afterInfo) {
+        const diff = diffTrees(beforeTree, {
+            key,
+            label: beforeTree.label,
+            children: [],
+        });
+        // Same as diffEntry: a removed root keeps the definition it had in `before`.
+        diff.status = "removed";
+        if (beforeTree.definition)
+            diff.definition = beforeTree.definition;
+        return diff;
+    }
+    const diff = diffTrees(beforeTree, afterTree);
+    if (!treeHasChanges(diff))
+        return null;
+    return diff;
+}

package/dist/languages/bash.d.ts

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