seendiff 0.0.2

package/src/git.js

@@ -0,0 +1,615 @@
+import { spawnSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import { readFileSync, statSync } from "node:fs";
+import path from "node:path";
+
+export const MERGE_GAP = 3;
+
+export const SECTION_MIN = 12;
+export const SECTION_MAX = 48;
+export const BASE_CANDIDATES = ["origin/master", "origin/main", "master", "main"];
+export const WHOLE_FILE_ID = "*";
+
+export class GitError extends Error { }
+
+function universalNewlines(s) {
+    return s.replace(/\r\n|\r/g, "\n");
+}
+
+function git(repo, ...args) {
+    const proc = spawnSync(
+        "git",
+        ["-C", repo, "-c", "core.quotePath=false", ...args],
+        { encoding: "utf8", maxBuffer: 1024 * 1024 * 512 }
+    );
+    if (proc.error) throw new GitError(`git ${args.join(" ")} failed: ${proc.error.message}`);
+    if (proc.status !== 0) {
+        throw new GitError(`git ${args.join(" ")} failed: ${(proc.stderr || "").trim()}`);
+    }
+    return universalNewlines(proc.stdout);
+}
+
+function gitQuiet(repo, ...args) {
+    return spawnSync("git", ["-C", repo, ...args], { encoding: "utf8" });
+}
+
+export function repoRoot(cwd = ".") {
+    try {
+        return git(cwd, "rev-parse", "--show-toplevel").trim();
+    } catch {
+        throw new GitError(`not inside a git repository: ${cwd}`);
+    }
+}
+
+export function resolveBase(repo, base = null) {
+    const candidates = base ? [base] : BASE_CANDIDATES;
+    for (const cand of candidates) {
+        const proc = gitQuiet(repo, "rev-parse", "--verify", "--quiet", `${cand}^{commit}`);
+        if (proc.status === 0) return cand;
+    }
+    throw new GitError("no base ref found; tried: " + candidates.join(", "));
+}
+
+export function mergeBase(repo, baseRef) {
+    return git(repo, "merge-base", baseRef, "HEAD").trim();
+}
+
+export function revSha(repo, ref = "HEAD") {
+    return git(repo, "rev-parse", ref).trim();
+}
+
+export function commitDate(repo, sha) {
+    return git(repo, "show", "-s", "--format=%cI", sha).trim();
+}
+
+export function branchName(repo) {
+    const proc = gitQuiet(repo, "symbolic-ref", "--short", "-q", "HEAD");
+    return proc.status === 0 ? proc.stdout.trim() : null;
+}
+
+export function dirtyAndConflicted(repo) {
+    const out = git(repo, "status", "--porcelain", "--untracked-files=no");
+    const dirty = [];
+    const conflicted = [];
+    for (const line of out.split("\n")) {
+        if (line.length < 4) continue;
+        const xy = line.slice(0, 2);
+        let p = line.slice(3);
+        if (p.includes(" -> ")) p = p.split(" -> ", 2)[1];
+        if (xy.includes("U") || xy === "AA" || xy === "DD") conflicted.push(p);
+        else dirty.push(p);
+    }
+    return [dirty, conflicted];
+}
+
+export function fetch(repo) {
+    git(repo, "fetch", "--quiet");
+}
+
+export function showFile(repo, sha, filePath) {
+    return git(repo, "show", `${sha}:${filePath}`);
+}
+
+function newLo(run) {
+    return run.tgtStart;
+}
+function newHi(run) {
+    return run.tgtLen ? run.tgtStart + run.tgtLen - 1 : run.tgtStart;
+}
+
+function blockNewStart(b) {
+    return Math.max(1, newLo(b.runs[0]));
+}
+function blockNewEnd(b) {
+    return Math.max(1, newHi(b.runs[b.runs.length - 1]));
+}
+function blockAdded(b) {
+    let n = 0;
+    for (const r of b.runs) for (const [t] of r.lines) if (t === "+") n++;
+    return n;
+}
+function blockRemoved(b) {
+    let n = 0;
+    for (const r of b.runs) for (const [t] of r.lines) if (t === "-") n++;
+    return n;
+}
+function blockKind(b) {
+    const added = blockAdded(b);
+    const removed = blockRemoved(b);
+    if (added && removed) return "mixed";
+    return added ? "add" : "del";
+}
+function blockBody(b) {
+    return b.runs.map((r) => r.lines.map(([t, text]) => t + text).join("")).join("");
+}
+
+export function decorateBlock(b) {
+    return {
+        ...b,
+        newStart: b.runs.length ? blockNewStart(b) : 1,
+        newEnd: b.runs.length ? blockNewEnd(b) : 1,
+        added: blockAdded(b),
+        removed: blockRemoved(b),
+        kind: b.runs.length ? blockKind(b) : "meta",
+    };
+}
+
+function fileStatus(pf) {
+    if (pf.isBinary) return "binary";
+    if (pf.isAdded) return "added";
+    if (pf.isRemoved) return "deleted";
+    if (pf.isRename) return "renamed";
+    return "modified";
+}
+
+function stripAB(p) {
+    if (p.startsWith("a/") || p.startsWith("b/")) return p.slice(2);
+    return p;
+}
+
+const DEF_RE =
+    /^(@\w|#\s*(define|include|pragma)\b|(export|default|public|private|protected|internal|static|final|abstract|pub|async|inline|extern)\s+)*(def|class|fn|func|function|impl|struct|enum|trait|interface|namespace|module|mod|package|type|template|const|let|var)\b/;
+
+function seamScore(lines, i) {
+    const [prevType, prevText] = lines[i - 1];
+    const [curType, curText] = lines[i];
+    let score = 0;
+    if (curType !== prevType) score += 4;
+    if (!prevText.trim()) score += 2;
+    const body = curText.replace(/[\r\n]+$/, "");
+    const stripped = body.replace(/^\s+/, "");
+    if (stripped) {
+        if (body.length - stripped.length === 0) score += 2;
+        if (DEF_RE.test(stripped)) score += 3;
+    }
+    return score;
+}
+
+function cutPoints(lines, lo, hi) {
+    const cuts = [];
+    let start = 0;
+    const n = lines.length;
+    while (n - start > hi) {
+        const lower = start + lo;
+        let upper = Math.min(start + hi, n - lo);
+        if (upper < lower) upper = Math.min(start + hi, n - 1);
+        if (upper < lower) break;
+        let best = lower;
+        let bestScore = seamScore(lines, lower);
+        for (let i = lower + 1; i <= upper; i++) {
+            const s = seamScore(lines, i);
+            if (s >= bestScore) {
+                bestScore = s;
+                best = i;
+            }
+        }
+        cuts.push(best);
+        start = best;
+    }
+    return cuts;
+}
+
+function splitRun(run, lo, hi) {
+    const cuts = cutPoints(run.lines, lo, hi);
+    if (!cuts.length) return [run];
+    const subs = [];
+    const bounds = [0, ...cuts, run.lines.length];
+    let dels = 0;
+    let adds = 0;
+    for (let i = 0; i < bounds.length - 1; i++) {
+        const loI = bounds[i];
+        const hiI = bounds[i + 1];
+        const seg = run.lines.slice(loI, hiI);
+        const nd = seg.filter(([t]) => t === "-").length;
+        const na = seg.length - nd;
+        subs.push({
+            srcStart: run.srcStart + dels,
+            srcLen: nd,
+            tgtStart: run.tgtStart + adds,
+            tgtLen: na,
+            lines: seg,
+        });
+        dels += nd;
+        adds += na;
+    }
+    return subs;
+}
+
+function changedCount(runs) {
+    return runs.reduce((n, r) => n + r.lines.length, 0);
+}
+
+export function splitBlocks(blocks, lo = SECTION_MIN, hi = SECTION_MAX) {
+    const out = [];
+    for (const b of blocks) {
+        if (changedCount(b.runs) <= hi) {
+            out.push(b);
+            continue;
+        }
+        let group = [];
+        for (const run of b.runs) {
+            if (run.lines.length > hi) {
+                if (group.length) {
+                    out.push({ runs: group, hunkId: "" });
+                    group = [];
+                }
+                for (const sub of splitRun(run, lo, hi)) out.push({ runs: [sub], hunkId: "" });
+                continue;
+            }
+            if (group.length && changedCount(group) + run.lines.length > hi) {
+                out.push({ runs: group, hunkId: "" });
+                group = [];
+            }
+            group.push(run);
+        }
+        if (group.length) out.push({ runs: group, hunkId: "" });
+    }
+    return out;
+}
+
+function groupBlocks(hunks) {
+    const blocks = [];
+    for (const run of hunks) {
+        if (blocks.length) {
+            const last = blocks[blocks.length - 1];
+            const lastRun = last.runs[last.runs.length - 1];
+            if (newLo(run) - newHi(lastRun) - 1 <= MERGE_GAP) {
+                last.runs.push(run);
+                continue;
+            }
+        }
+        blocks.push({ runs: [run], hunkId: "" });
+    }
+    return blocks;
+}
+
+export function assignIds(blocks) {
+    const seen = new Map();
+    for (const b of blocks) {
+        const h = createHash("sha256").update(blockBody(b), "utf8").digest("hex").slice(0, 16);
+        const n = (seen.get(h) || 0) + 1;
+        seen.set(h, n);
+        b.hunkId = n === 1 ? h : `${h}-${n}`;
+    }
+}
+
+const SUBPROJECT = "Subproject commit ";
+
+const RE_DIFF_GIT = /^diff --git (?:"?a\/(.+?)"?) (?:"?b\/(.+?)"?)$/;
+const RE_HUNK = /^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/;
+
+function parseUnifiedDiff(text) {
+    const lines = text.split("\n");
+    const files = [];
+    let i = 0;
+    let cur = null;
+
+    function push() {
+        if (cur) files.push(cur);
+        cur = null;
+    }
+
+    while (i < lines.length) {
+        const line = lines[i];
+        const m = RE_DIFF_GIT.exec(line);
+        if (m) {
+            push();
+            cur = {
+                sourceFile: m[1],
+                targetFile: m[2],
+                path: m[2],
+                isBinary: false,
+                isAdded: false,
+                isRemoved: false,
+                isRename: false,
+                added: 0,
+                removed: 0,
+                hunks: [],
+            };
+            i++;
+            continue;
+        }
+        if (!cur) {
+            i++;
+            continue;
+        }
+        if (line.startsWith("new file mode")) {
+            cur.isAdded = true;
+            i++;
+            continue;
+        }
+        if (line.startsWith("deleted file mode")) {
+            cur.isRemoved = true;
+            i++;
+            continue;
+        }
+        if (line.startsWith("rename from ")) {
+            cur.isRename = true;
+            cur.sourceFile = line.slice("rename from ".length);
+            i++;
+            continue;
+        }
+        if (line.startsWith("rename to ")) {
+            cur.isRename = true;
+            cur.targetFile = line.slice("rename to ".length);
+            cur.path = cur.targetFile;
+            i++;
+            continue;
+        }
+        if (line.startsWith("copy from ")) {
+            cur.isRename = true;
+            cur.sourceFile = line.slice("copy from ".length);
+            i++;
+            continue;
+        }
+        if (line.startsWith("copy to ")) {
+            cur.isRename = true;
+            cur.targetFile = line.slice("copy to ".length);
+            cur.path = cur.targetFile;
+            i++;
+            continue;
+        }
+        if (line.startsWith("Binary files") || line.startsWith("GIT binary patch")) {
+            cur.isBinary = true;
+            i++;
+            continue;
+        }
+        if (line.startsWith("--- ") || line.startsWith("+++ ")) {
+            i++;
+            continue;
+        }
+        const hm = RE_HUNK.exec(line);
+        if (hm) {
+            const srcStart = parseInt(hm[1], 10);
+            const srcLen = hm[2] !== undefined ? parseInt(hm[2], 10) : 1;
+            const tgtStart = parseInt(hm[3], 10);
+            const tgtLen = hm[4] !== undefined ? parseInt(hm[4], 10) : 1;
+            i++;
+            const hunkLines = [];
+            while (i < lines.length) {
+                const hl = lines[i];
+                if (hl.startsWith("diff --git") || RE_HUNK.test(hl)) break;
+                if (hl.startsWith("\")) {
+                    i++;
+                    continue;
+                }
+                if (hl.startsWith("+")) {
+                    hunkLines.push(["+", hl.slice(1) + "\n"]);
+                    cur.added++;
+                } else if (hl.startsWith("-")) {
+                    hunkLines.push(["-", hl.slice(1) + "\n"]);
+                    cur.removed++;
+                } else if (hl === "") {
+                    i++;
+                    continue;
+                } else {
+                    break;
+                }
+                i++;
+            }
+            cur.hunks.push({ srcStart, srcLen, tgtStart, tgtLen, lines: hunkLines });
+            continue;
+        }
+        i++;
+    }
+    push();
+    return files;
+}
+
+export function identityDiff(repo, mbSha, rev = "HEAD", sectionMin = SECTION_MIN, sectionMax = SECTION_MAX) {
+    const out = git(
+        repo,
+        "diff",
+        "--no-ext-diff",
+        "--no-color",
+        "--unified=0",
+        "--find-renames",
+        mbSha,
+        rev,
+        "--"
+    );
+    const files = [];
+    for (const pf of parseUnifiedDiff(out)) {
+        const status = fileStatus(pf);
+        const runs = pf.hunks.map((h) => ({
+            srcStart: h.srcStart,
+            srcLen: h.srcLen,
+            tgtStart: h.tgtStart,
+            tgtLen: h.tgtLen,
+            lines: h.lines,
+        }));
+        let blocks = splitBlocks(groupBlocks(runs), sectionMin, sectionMax);
+        assignIds(blocks);
+        const fd = {
+            runs,
+            path: stripAB(pf.path),
+            oldPath: pf.isRename ? stripAB(pf.sourceFile) : null,
+            status,
+            added: pf.added || 0,
+            removed: pf.removed || 0,
+            blocks,
+            sub: null,
+        };
+        if (!fd.blocks.length) {
+            if (fd.status === "modified") {
+                fd.status = pf.isRename ? "renamed" : "meta";
+            }
+            fd.blocks = [{ runs: [], hunkId: WHOLE_FILE_ID }];
+        }
+        const changed = fd.blocks.flatMap((b) => b.runs.flatMap((r) => r.lines.map(([, text]) => text)));
+        if (changed.length && changed.every((t) => t.startsWith(SUBPROJECT))) {
+            fd.status = "submodule";
+        }
+        files.push(fd);
+    }
+    return files;
+}
+
+function pointerShas(fd) {
+    let oldSha = null;
+    let newSha = null;
+    for (const b of fd.blocks) {
+        for (const r of b.runs) {
+            for (const [t, text] of r.lines) {
+                const sha = text.slice(SUBPROJECT.length).trim().replace(/-dirty$/, "");
+                if (t === "-") oldSha = sha;
+                else newSha = sha;
+            }
+        }
+    }
+    return [oldSha, newSha];
+}
+
+export function expandSubmodules(repo, files, sectionMin = SECTION_MIN, sectionMax = SECTION_MAX) {
+    const out = [];
+    for (const fd of files) {
+        out.push(fd);
+        if (fd.status !== "submodule") continue;
+        const [oldSha, newSha] = pointerShas(fd);
+        const subRepo = path.join(repo, fd.path);
+        if (!oldSha || !newSha) continue;
+        try {
+            if (!statSync(subRepo).isDirectory()) continue;
+        } catch {
+            continue;
+        }
+        let inner;
+        try {
+            inner = identityDiff(subRepo, oldSha, newSha, sectionMin, sectionMax);
+        } catch (e) {
+            if (e instanceof GitError) continue;
+            throw e;
+        }
+        for (const ifd of inner) {
+            ifd.sub = { repo: subRepo, old: oldSha, new: newSha, rel: ifd.path, oldRel: ifd.oldPath };
+            ifd.path = `${fd.path}/${ifd.path}`;
+            if (ifd.oldPath) ifd.oldPath = `${fd.path}/${ifd.oldPath}`;
+            out.push(ifd);
+        }
+    }
+    return out;
+}
+
+export const WORKTREE_MAX_BYTES = 5_000_000;
+
+export function worktreeRows(repo, filePath) {
+    const full = path.join(repo, filePath);
+    let raw;
+    try {
+        raw = readFileSync(full);
+    } catch (e) {
+        throw new GitError(`cannot read ${filePath}: ${e.message}`);
+    }
+    if (raw.length > WORKTREE_MAX_BYTES) {
+        throw new GitError(`${filePath} too large (${Math.floor(raw.length / 1024)} kB)`);
+    }
+    if (raw.subarray(0, 8192).includes(0)) {
+        throw new GitError(`${filePath} is binary`);
+    }
+    const lines = splitText(raw.toString("utf8"));
+    return lines.map((line, i) => ({ old: i + 1, new: i + 1, type: "context", text: line, hunkId: null }));
+}
+
+function splitText(text) {
+    const lines = text.split("\n");
+    if (lines.length && lines[lines.length - 1] === "") lines.pop();
+    return lines;
+}
+
+function rowsFromRuns(runs, newText, filePath) {
+    const newLines = splitText(newText);
+    const rows = [];
+    let oldI = 1;
+    let newI = 1;
+    for (const r of runs) {
+        const ctxEnd = r.tgtLen ? r.tgtStart - 1 : r.tgtStart;
+        if (ctxEnd > newLines.length || ctxEnd < newI - 1) {
+            throw new GitError(
+                `${filePath}: hunk at new line ${r.tgtStart} does not fit the file (${newLines.length} lines) — it changed under us`
+            );
+        }
+        while (newI <= ctxEnd) {
+            rows.push({ old: oldI, new: newI, type: "context", text: newLines[newI - 1], hunkId: null });
+            oldI++;
+            newI++;
+        }
+        const dels = r.lines.filter(([k]) => k === "-").map(([, t]) => t);
+        const adds = r.lines.filter(([k]) => k === "+").map(([, t]) => t);
+        dels.forEach((t, i) => rows.push({ old: r.srcStart + i, new: null, type: "del", text: t.replace(/\n$/, ""), hunkId: null }));
+        adds.forEach((t, i) => rows.push({ old: null, new: r.tgtStart + i, type: "add", text: t.replace(/\n$/, ""), hunkId: null }));
+        if (r.srcLen) oldI = r.srcStart + r.srcLen;
+        if (r.tgtLen) newI = r.tgtStart + r.tgtLen;
+    }
+    while (newI <= newLines.length) {
+        rows.push({ old: oldI, new: newI, type: "context", text: newLines[newI - 1], hunkId: null });
+        oldI++;
+        newI++;
+    }
+    return rows;
+}
+
+function tagRows(rows, blocks) {
+    const byNew = new Map();
+    const byOld = new Map();
+    for (const b of blocks) {
+        for (const r of b.runs) {
+            for (let n = r.tgtStart; n < r.tgtStart + r.tgtLen; n++) byNew.set(n, b.hunkId);
+            for (let n = r.srcStart; n < r.srcStart + r.srcLen; n++) byOld.set(n, b.hunkId);
+        }
+    }
+    for (const row of rows) {
+        if (row.type === "add") row.hunkId = byNew.get(row.new) ?? null;
+        else if (row.type === "del") row.hunkId = byOld.get(row.old) ?? null;
+    }
+}
+
+export function verifyTagging(rows, blocks, filePath) {
+    const untagged = rows.filter((r) => r.type !== "context" && r.hunkId == null);
+    if (untagged.length) {
+        const r = untagged[0];
+        throw new Error(
+            `${filePath}: ${untagged.length} changed row(s) not covered by any block, first at old=${r.old} new=${r.new} '${r.type}'`
+        );
+    }
+    const taggedIds = new Set(rows.filter((r) => r.hunkId).map((r) => r.hunkId));
+    const empty = blocks.filter((b) => b.runs.length && !taggedIds.has(b.hunkId)).map((b) => b.hunkId);
+    if (empty.length) {
+        throw new Error(`${filePath}: block(s) ${empty} matched no rows`);
+    }
+}
+
+export function displayRows(repo, mbSha, fd) {
+    const gitRepo = fd.sub ? fd.sub.repo : repo;
+    const base = fd.sub ? fd.sub.old : mbSha;
+    const rev = fd.sub ? fd.sub.new : "HEAD";
+    const rel = fd.sub ? fd.sub.rel : fd.path;
+
+    let rows;
+    if (fd.status === "submodule") {
+        rows = rowsFromRuns(fd.runs, "", fd.path);
+    } else if (fd.status === "deleted") {
+        const lines = splitText(showFile(gitRepo, base, rel));
+        rows = lines.map((line, i) => ({ old: i + 1, new: null, type: "del", text: line, hunkId: null }));
+    } else if (fd.status !== "binary" && fd.status !== "meta" && fd.runs.length) {
+        rows = rowsFromRuns(fd.runs, showFile(gitRepo, rev, rel), fd.path);
+    } else {
+        let text;
+        try {
+            text = showFile(gitRepo, rev, rel);
+        } catch (e) {
+            if (e instanceof GitError) return [];
+            throw e;
+        }
+        return splitText(text).map((line, i) => ({ old: i + 1, new: i + 1, type: "context", text: line, hunkId: null }));
+    }
+
+    tagRows(rows, fd.blocks);
+    try {
+        verifyTagging(rows, fd.blocks, fd.path);
+    } catch (e) {
+        process.stderr.write(
+            `seendiff: tagging invariant broken, showing ${fd.path} without block marks — please report: ${e.message}\n`
+        );
+    }
+    return rows;
+}