limn-review 0.1.123

package/dist/conflict/diff.js

@@ -0,0 +1,304 @@
+/**
+ * Myers O(ND) with the linear-space divide-and-conquer refinement, common prefix and suffix
+ * trimmed at every level.
+ *
+ * `maxD` is a BUDGET over the whole recursion, not per call: a pathological pair (a file
+ * rewritten wholesale) would otherwise spend minutes proving what a single whole-file region
+ * says just as well. Returns `null` when the budget runs out — the caller degrades that file
+ * to one conflict spanning everything, which is honest and still resolvable.
+ */
+export function diffTokens(a, b, maxD) {
+    const out = [];
+    const budget = { left: Math.max(1, maxD) };
+    if (!bisectInto(a, b, 0, a.length, 0, b.length, out, budget))
+        return null;
+    return coalesce(out);
+}
+/** Merge changes that touch, so the caller never sees two adjacent ranges with nothing
+ *  between them. The recursion can produce those at a split point. */
+function coalesce(changes) {
+    const out = [];
+    for (const c of changes) {
+        const prev = out[out.length - 1];
+        if (prev && prev.aEnd === c.aStart && prev.bEnd === c.bStart) {
+            prev.aEnd = c.aEnd;
+            prev.bEnd = c.bEnd;
+            continue;
+        }
+        out.push({ ...c });
+    }
+    return out.filter((c) => c.aEnd > c.aStart || c.bEnd > c.bStart);
+}
+function bisectInto(a, b, a0, a1, b0, b1, out, budget) {
+    // Trim the common prefix and suffix first: it is what keeps `d` small on a real edit, and
+    // it is also what makes the base cases below reachable at all.
+    while (a0 < a1 && b0 < b1 && a[a0] === b[b0]) {
+        a0++;
+        b0++;
+    }
+    while (a0 < a1 && b0 < b1 && a[a1 - 1] === b[b1 - 1]) {
+        a1--;
+        b1--;
+    }
+    if (a0 === a1 && b0 === b1)
+        return true;
+    if (a0 === a1 || b0 === b1) {
+        // Pure insertion or pure deletion — nothing left to align.
+        out.push({ aStart: a0, aEnd: a1, bStart: b0, bEnd: b1 });
+        return true;
+    }
+    const split = middleSnake(a, b, a0, a1, b0, b1, budget);
+    if (split.kind === 'budget')
+        return false;
+    if (split.kind === 'replace') {
+        // The frontiers never met inside `max`, which for a correct Myers should not happen.
+        // Falling back to a whole-range replacement is coarser than optimal but never WRONG,
+        // and it is a great deal better than reporting a wrong split.
+        out.push({ aStart: a0, aEnd: a1, bStart: b0, bEnd: b1 });
+        return true;
+    }
+    if (!bisectInto(a, b, a0, split.x, b0, split.y, out, budget))
+        return false;
+    if (!bisectInto(a, b, split.x, a1, split.y, b1, out, budget))
+        return false;
+    return true;
+}
+/**
+ * Find the middle snake of the optimal edit script (Myers §4b) — the forward and reverse
+ * frontiers advance one `d` at a time until they overlap, and the overlap point splits the
+ * problem in half with O(N+M) memory.
+ */
+function middleSnake(a, b, a0, a1, b0, b1, budget) {
+    const n = a1 - a0;
+    const m = b1 - b0;
+    const max = Math.ceil((n + m) / 2);
+    const offset = max;
+    const len = 2 * max + 2;
+    const vf = new Int32Array(len).fill(-1);
+    const vr = new Int32Array(len).fill(-1);
+    vf[offset + 1] = 0;
+    vr[offset + 1] = 0;
+    const delta = n - m;
+    // When delta is odd the frontiers can only meet on a FORWARD step, and vice versa.
+    const front = (delta & 1) !== 0;
+    let k1start = 0;
+    let k1end = 0;
+    let k2start = 0;
+    let k2end = 0;
+    // ⚠ `d <= max`, not `d < max`. The frontiers meet at `d = ceil(D/2)` and `D` can be the
+    // full `n + m` — a one-token replacement is D = 2, max = 1, and a `d < max` loop never
+    // runs the step that finds it. That off-by-one turns every small edit into a whole-range
+    // replacement, which still merges correctly and reads as one enormous conflict on screen.
+    for (let d = 0; d <= max; d++) {
+        if (budget.left-- <= 0)
+            return { kind: 'budget' };
+        for (let k1 = -d + k1start; k1 <= d - k1end; k1 += 2) {
+            const k1off = offset + k1;
+            let x1;
+            if (k1 === -d || (k1 !== d && (vf[k1off - 1] ?? -1) < (vf[k1off + 1] ?? -1))) {
+                x1 = vf[k1off + 1] ?? 0;
+            }
+            else {
+                x1 = (vf[k1off - 1] ?? 0) + 1;
+            }
+            let y1 = x1 - k1;
+            while (x1 < n && y1 < m && a[a0 + x1] === b[b0 + y1]) {
+                x1++;
+                y1++;
+            }
+            vf[k1off] = x1;
+            if (x1 > n) {
+                k1end += 2;
+            }
+            else if (y1 > m) {
+                k1start += 2;
+            }
+            else if (front) {
+                const k2off = offset + delta - k1;
+                if (k2off >= 0 && k2off < len && (vr[k2off] ?? -1) !== -1) {
+                    const x2 = n - (vr[k2off] ?? 0);
+                    if (x1 >= x2)
+                        return { kind: 'split', x: a0 + x1, y: b0 + y1 };
+                }
+            }
+        }
+        for (let k2 = -d + k2start; k2 <= d - k2end; k2 += 2) {
+            const k2off = offset + k2;
+            let x2;
+            if (k2 === -d || (k2 !== d && (vr[k2off - 1] ?? -1) < (vr[k2off + 1] ?? -1))) {
+                x2 = vr[k2off + 1] ?? 0;
+            }
+            else {
+                x2 = (vr[k2off - 1] ?? 0) + 1;
+            }
+            let y2 = x2 - k2;
+            while (x2 < n && y2 < m && a[a0 + n - x2 - 1] === b[b0 + m - y2 - 1]) {
+                x2++;
+                y2++;
+            }
+            vr[k2off] = x2;
+            if (x2 > n) {
+                k2end += 2;
+            }
+            else if (y2 > m) {
+                k2start += 2;
+            }
+            else if (!front) {
+                const k1off = offset + delta - k2;
+                if (k1off >= 0 && k1off < len && (vf[k1off] ?? -1) !== -1) {
+                    const x1 = vf[k1off] ?? 0;
+                    const y1 = x1 - (k1off - offset);
+                    if (x1 >= n - x2)
+                        return { kind: 'split', x: a0 + x1, y: b0 + y1 };
+                }
+            }
+        }
+    }
+    return { kind: 'replace' };
+}
+function toHunks(changes) {
+    return changes.map((c) => ({
+        baseStart: c.aStart,
+        baseEnd: c.aEnd,
+        sideStart: c.bStart,
+        sideEnd: c.bEnd,
+    }));
+}
+/**
+ * The classic diff3 chunker. Takes both sides' diffs AGAINST THE BASE and produces one
+ * ordered region list covering the base end to end.
+ *
+ * ⚠ ADJACENT CHANGES ABSORB INTO ONE REGION (`hunk.baseStart <= hi`, zero unchanged tokens
+ * between). Two edits that touch are one contested region: offering them separately lets the
+ * reader take ours from the first and theirs from the second and produce text neither author
+ * wrote.
+ *
+ * ⚠ `both_same` is a real kind and is NOT collapsed into `ours_only`. Collapsing it makes the
+ * wand's "what I did" count wrong — it settled nothing there, both authors already agreed.
+ */
+export function threeWayChunks(base, ours, theirs, oursChanges, theirsChanges) {
+    const oursHunks = toHunks(oursChanges);
+    const theirsHunks = toHunks(theirsChanges);
+    const regions = [];
+    let i = 0;
+    let j = 0;
+    let basePos = 0;
+    while (i < oursHunks.length || j < theirsHunks.length) {
+        const nextOurs = oursHunks[i];
+        const nextTheirs = theirsHunks[j];
+        let lo;
+        if (nextOurs && nextTheirs)
+            lo = Math.min(nextOurs.baseStart, nextTheirs.baseStart);
+        else if (nextOurs)
+            lo = nextOurs.baseStart;
+        else if (nextTheirs)
+            lo = nextTheirs.baseStart;
+        else
+            break;
+        let hi = lo;
+        const groupOurs = [];
+        const groupTheirs = [];
+        // Absorb every hunk from either side that starts at or before the group's current end.
+        for (;;) {
+            const o = oursHunks[i];
+            const t = theirsHunks[j];
+            if (o && o.baseStart <= hi) {
+                groupOurs.push(o);
+                hi = Math.max(hi, o.baseEnd);
+                i++;
+                continue;
+            }
+            if (t && t.baseStart <= hi) {
+                groupTheirs.push(t);
+                hi = Math.max(hi, t.baseEnd);
+                j++;
+                continue;
+            }
+            break;
+        }
+        if (lo > basePos) {
+            regions.push(unchangedRegion(basePos, lo, oursHunks, theirsHunks));
+        }
+        const oursRange = mapRange(lo, hi, groupOurs, oursHunks);
+        const theirsRange = mapRange(lo, hi, groupTheirs, theirsHunks);
+        const kind = classify(base.slice(lo, hi), ours.slice(oursRange.start, oursRange.end), theirs.slice(theirsRange.start, theirsRange.end));
+        regions.push({
+            kind,
+            baseStart: lo,
+            baseEnd: hi,
+            oursStart: oursRange.start,
+            oursEnd: oursRange.end,
+            theirsStart: theirsRange.start,
+            theirsEnd: theirsRange.end,
+        });
+        basePos = hi;
+    }
+    if (basePos < base.length) {
+        regions.push(unchangedRegion(basePos, base.length, oursHunks, theirsHunks));
+    }
+    return regions;
+}
+function unchangedRegion(lo, hi, oursHunks, theirsHunks) {
+    const o = mapRange(lo, hi, [], oursHunks);
+    const t = mapRange(lo, hi, [], theirsHunks);
+    return {
+        kind: 'unchanged',
+        baseStart: lo,
+        baseEnd: hi,
+        oursStart: o.start,
+        oursEnd: o.end,
+        theirsStart: t.start,
+        theirsEnd: t.end,
+    };
+}
+/**
+ * Map a base range onto one side.
+ *
+ * With hunks in the group, the group's own first and last hunk anchor it: the run between
+ * `lo` and the first hunk's start is unchanged on this side, so it shifts by the same amount,
+ * and likewise at the tail. Without any, the whole range is unchanged on this side and the
+ * mapping is the cumulative offset of every hunk that ended before `lo`.
+ */
+function mapRange(lo, hi, group, allHunks) {
+    const first = group[0];
+    const last = group[group.length - 1];
+    if (first && last) {
+        return {
+            start: first.sideStart - (first.baseStart - lo),
+            end: last.sideEnd + (hi - last.baseEnd),
+        };
+    }
+    let offset = 0;
+    for (const h of allHunks) {
+        if (h.baseEnd <= lo)
+            offset += h.sideEnd - h.sideStart - (h.baseEnd - h.baseStart);
+        else
+            break;
+    }
+    return { start: lo + offset, end: hi + offset };
+}
+function sameTokens(a, b) {
+    if (a.length !== b.length)
+        return false;
+    for (let k = 0; k < a.length; k++)
+        if (a[k] !== b[k])
+            return false;
+    return true;
+}
+/** Classify by CONTENT, not by which hunk lists contributed. After absorption a group can
+ *  hold a hunk from a side whose net text is identical to the base's, and calling that a
+ *  change would show the reader a choice between two identical things. */
+function classify(base, ours, theirs) {
+    const oursSame = sameTokens(base, ours);
+    const theirsSame = sameTokens(base, theirs);
+    if (oursSame && theirsSame)
+        return 'unchanged';
+    if (theirsSame)
+        return 'ours_only';
+    if (oursSame)
+        return 'theirs_only';
+    if (sameTokens(ours, theirs))
+        return 'both_same';
+    return 'conflict';
+}
+//# sourceMappingURL=diff.js.map

package/dist/conflict/git.js

@@ -0,0 +1,118 @@
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+const execFileAsync = promisify(execFile);
+/**
+ * The git environment for EVERY command the conflict resolver runs — discovery and landing
+ * alike. Stricter than `coding/merge.ts`'s GIT_ENV on purpose.
+ *
+ * A developer's global git config must not change what we COMPUTE or what we COMMIT:
+ * `merge.conflictStyle`, `diff.algorithm`, `diff.renames` and custom merge drivers all move
+ * the answer. MEASURED: the same `merge-tree` on the same two commits wrote tree 0bc8605
+ * with global config nulled and bf04533 with `merge.conflictStyle=zdiff3`.
+ *
+ * ⚠ EXPORTED because the land path seeds from merge-tree's tree — the user must not review
+ * one merge and push another. In-tree `.gitattributes` stays honoured on purpose: it is part
+ * of the repository, and turning it off would change how the repo's own owners merge.
+ */
+export const CONFLICT_GIT_ENV = {
+    ...process.env,
+    GIT_TERMINAL_PROMPT: '0',
+    GIT_EDITOR: 'true',
+    GIT_CONFIG_GLOBAL: '/dev/null',
+    GIT_CONFIG_SYSTEM: '/dev/null',
+    GIT_ATTR_NOSYSTEM: '1',
+    GIT_OPTIONAL_LOCKS: '0',
+    GIT_ADVICE: '0',
+};
+// `merge-tree -z`, `diff-tree -z` and `cat-file --batch` are NUL-delimited and byte-oriented,
+// and blobs are arbitrary bytes. Decoding stdout to a string anywhere in this pipeline is how
+// a Latin-1 file becomes U+FFFD, so stdout is a Buffer the whole way down and only the strict
+// UTF-8 gate in model.ts is allowed to turn bytes into text.
+const MAX_BUFFER = 256 * 1024 * 1024;
+const TIMEOUT_MS = 120_000;
+/** Run git, throwing on a non-zero exit (for the commands that MUST succeed). */
+export async function git(args, cwd, stdin, env) {
+    const res = await gitTry(args, cwd, stdin, env);
+    if (res.code !== 0) {
+        throw new Error(`git ${args.slice(0, 3).join(' ')} failed (${res.code}): ${res.stderr.slice(0, 500)}`);
+    }
+    return { stdout: res.stdout, stderr: res.stderr };
+}
+/**
+ * Run git WITHOUT throwing; returns the exit code plus output.
+ *
+ * `env` is MERGED OVER `CONFLICT_GIT_ENV`, for the two variables the land path needs and
+ * that have no command-line equivalent: `GIT_INDEX_FILE` (the scratch index every tree is
+ * built in, so the shared clone's own index is never touched) and `GIT_AUTHOR_*` (a rebased
+ * commit keeps the original author while the account is the committer).
+ *
+ * ⚠ Several commands here exit non-zero on complete success — `merge-tree` exits 1 when it
+ * finds conflicts, and the by-OID prefetch exits non-zero even when every object landed.
+ * Callers branch on the OUTPUT, never on the code alone.
+ */
+export async function gitTry(args, cwd, stdin, env) {
+    return new Promise((resolve, reject) => {
+        const child = execFile('git', args, {
+            cwd,
+            // ⚠ The overrides go AFTER the constant, never before: `GIT_INDEX_FILE` and the
+            // `GIT_AUTHOR_*` ident the land path sets must be additions to the hardened env, not
+            // a replacement for it. A caller cannot re-open `GIT_CONFIG_GLOBAL` by accident, only
+            // deliberately, and nothing does.
+            env: env ? { ...CONFLICT_GIT_ENV, ...env } : CONFLICT_GIT_ENV,
+            timeout: TIMEOUT_MS,
+            maxBuffer: MAX_BUFFER,
+            encoding: 'buffer',
+        }, (err, stdout, stderr) => {
+            const out = Buffer.isBuffer(stdout) ? stdout : Buffer.from(String(stdout));
+            const errText = Buffer.isBuffer(stderr) ? stderr.toString('utf8') : String(stderr);
+            if (err) {
+                const code = err.code;
+                // A numeric `code` is git's exit status. A string one (ENOENT, ETIMEDOUT) means the
+                // process never ran or was killed, which is a real failure, not a git verdict.
+                if (typeof code === 'number') {
+                    resolve({ code, stdout: out, stderr: errText });
+                    return;
+                }
+                reject(err);
+                return;
+            }
+            resolve({ code: 0, stdout: out, stderr: errText });
+        });
+        if (stdin !== undefined) {
+            child.stdin?.end(stdin);
+        }
+    });
+}
+/**
+ * `git merge-tree --write-tree` needs git 2.38. Probed ONCE per process and memoised — the
+ * open route turns a false into `git_too_old` and the overlay prints it once.
+ *
+ * ⚠ This is NOT on `/api/me`. `MeResponse.conflictResolver` is `!config.isCloud` and shells
+ * out to nothing; probing git on every SPA boot to answer a question the open route can
+ * answer once is the trade this replaced.
+ */
+let versionProbe = null;
+export function gitSupportsMergeTree(cwd = process.cwd()) {
+    versionProbe ??= (async () => {
+        try {
+            const { stdout } = await gitTry(['--version'], cwd);
+            const m = /git version (\d+)\.(\d+)/.exec(stdout.toString('utf8'));
+            if (!m)
+                return false;
+            const major = Number(m[1]);
+            const minor = Number(m[2]);
+            if (!Number.isFinite(major) || !Number.isFinite(minor))
+                return false;
+            return major > 2 || (major === 2 && minor >= 38);
+        }
+        catch {
+            return false;
+        }
+    })();
+    return versionProbe;
+}
+/** Test seam only: forget the memoised probe. */
+export function resetGitVersionProbe() {
+    versionProbe = null;
+}
+//# sourceMappingURL=git.js.map

package/dist/conflict/hash.js

@@ -0,0 +1,73 @@
+import { createHash } from 'node:crypto';
+import { CONFLICT_MODEL_VERSION } from '../shared/index.js';
+/**
+ * The model hash. Echoed on the commit body; a mismatch is `ModelStale` and nothing is
+ * written, because a decision made against different bytes is not a decision.
+ *
+ * ⚠ `CONFLICT_MODEL_VERSION` IS FOLDED IN, so a change to the fold or the chunker
+ * self-invalidates every live session rather than landing bytes the user did not choose —
+ * the `PERIOD_METRICS_SCHEMA_VERSION` discipline.
+ *
+ * ⚠ ONLY MODEL FACTS GO IN. Nothing `Date.now()`-derived, nothing hydrated, nothing that
+ * depends on how the session was OPENED: `autoApply` changes which decision a region starts
+ * on, not what the region IS, and folding it in would make the same model hash two different
+ * values depending on a checkbox.
+ */
+export function conflictModelHash(model) {
+    const h = createHash('sha256');
+    const put = (s) => {
+        h.update(s);
+        h.update('\0');
+    };
+    put(`v${CONFLICT_MODEL_VERSION}`);
+    put(model.headSha);
+    put(model.baseSha);
+    put(model.mergedTreeSha);
+    put(model.mergeBaseSha ?? '');
+    put(model.mergeBaseIsVirtual ? '1' : '0');
+    put(String(model.totalConflictedPaths));
+    put(model.truncated ? '1' : '0');
+    put(model.renameDetection);
+    for (const f of model.files) {
+        put(String(f.index));
+        put(f.path);
+        put(f.unsupported ?? '');
+        put(f.stage2Mode ?? '');
+        put(`${f.terminators.base ? 1 : 0}${f.terminators.ours ? 1 : 0}${f.terminators.theirs ? 1 : 0}`);
+        put(String(f.regions.length));
+        for (const r of f.regions) {
+            put(String(r.id));
+            put(r.kind);
+            // The fingerprint already covers all three sides' bytes, so hashing it rather than the
+            // lines keeps this linear in region count instead of in file size.
+            put(r.fingerprint);
+            put(r.wand?.decision ?? '');
+            put(r.wand?.reason ?? '');
+            put(r.mergedLines === null ? '' : regionMergeDigest(r));
+        }
+    }
+    return h.digest('hex');
+}
+function regionMergeDigest(region) {
+    const h = createHash('sha256');
+    for (const line of region.mergedLines ?? []) {
+        h.update(line);
+        h.update('\0');
+    }
+    return h.digest('hex');
+}
+/** sha256 of `base \0 ours \0 theirs`. The CONTENT pin the Pro suggestion route checks
+ *  against the id's ADDRESS — a region can keep its id while its bytes move only if the
+ *  whole model was rebuilt, and then this differs. */
+export function regionFingerprint(base, ours, theirs) {
+    const h = createHash('sha256');
+    for (const side of [base, ours, theirs]) {
+        for (const line of side) {
+            h.update(line);
+            h.update('\n');
+        }
+        h.update('\0');
+    }
+    return h.digest('hex');
+}
+//# sourceMappingURL=hash.js.map