@coderook/cli 0.31.13 → 0.32.0

package/dist/cbx/src/local/merge.js

@@ -0,0 +1,277 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MergeInProgress = void 0;
+exports.readMergeState = readMergeState;
+exports.clearMergeState = clearMergeState;
+exports.mergeBase = mergeBase;
+exports.isAncestor = isAncestor;
+exports.mergeInto = mergeInto;
+exports.unresolved = unresolved;
+exports.takeSide = takeSide;
+/**
+ * Merging two lines of a local history.
+ *
+ * Every path is decided by comparing both sides with the save they last had
+ * in common. A file only one side changed is taken from that side, a file
+ * both changed the same way is taken once, and a text file both changed
+ * differently is merged line by line. Only what is left after that is a
+ * conflict: marked in the file for text, and for anything else left as this
+ * side had it and named, so a person decides.
+ *
+ * A merge with no conflicts is saved at once with both saves as parents. One
+ * with conflicts writes what it could into the folder and waits in
+ * `.cbx/merge.json` until the person saves (which makes the merge save) or
+ * cancels (which puts the folder back).
+ */
+const promises_1 = require("node:fs/promises");
+const node_path_1 = __importDefault(require("node:path"));
+const merge_diff_js_1 = require("../shared/merge_diff.js");
+const snapshot_js_1 = require("./snapshot.js");
+const merge_text_js_1 = require("./merge_text.js");
+const errors_js_1 = require("./errors.js");
+/** Past this a file is not merged line by line. */
+const TEXT_LIMIT = 4 * 1024 * 1024;
+const MERGE_FILE = "merge.json";
+class MergeInProgress extends Error {
+}
+exports.MergeInProgress = MergeInProgress;
+async function readMergeState(repository) {
+    try {
+        return JSON.parse(await (0, promises_1.readFile)(node_path_1.default.join(repository.directory, MERGE_FILE), "utf8"));
+    }
+    catch {
+        return null;
+    }
+}
+async function writeMergeState(repository, state) {
+    const target = node_path_1.default.join(repository.directory, MERGE_FILE);
+    if (!state) {
+        await (0, promises_1.rm)(target, { force: true });
+        return;
+    }
+    await (0, promises_1.writeFile)(`${target}.partial`, JSON.stringify(state, null, 2));
+    await (0, promises_1.rename)(`${target}.partial`, target);
+}
+async function clearMergeState(repository) {
+    await writeMergeState(repository, null);
+}
+/** Every ancestor of `from`, itself included, through all parents. */
+async function ancestors(repository, from) {
+    const seen = new Set();
+    const queue = [from];
+    while (queue.length) {
+        const id = queue.shift();
+        if (seen.has(id))
+            continue;
+        seen.add(id);
+        queue.push(...(await repository.readSave(id)).parents);
+    }
+    return seen;
+}
+/** The nearest save both descend from, or null for unrelated histories. */
+async function mergeBase(repository, left, right) {
+    const mine = await ancestors(repository, left);
+    const seen = new Set();
+    const queue = [right];
+    while (queue.length) {
+        const id = queue.shift();
+        if (mine.has(id))
+            return id;
+        if (seen.has(id))
+            continue;
+        seen.add(id);
+        queue.push(...(await repository.readSave(id)).parents);
+    }
+    return null;
+}
+async function isAncestor(repository, ancestor, of) {
+    return (await ancestors(repository, of)).has(ancestor);
+}
+const byPath = (tree) => new Map(tree.files.map((file) => [file.path, file]));
+function looksBinary(bytes) {
+    return bytes.subarray(0, 8192).includes(0);
+}
+/**
+ * Merge the save `theirs` into the folder's line. Assumes the lock is held;
+ * `merge` in history.ts is the public way in.
+ */
+async function mergeInto(repository, theirs, options) {
+    if (await readMergeState(repository)) {
+        throw new MergeInProgress("A merge is already waiting on conflicts. Resolve them and save, or cancel it with cbx merge --cancel.");
+    }
+    const line = await repository.currentLine();
+    const ours = await repository.head();
+    const theirSave = await repository.readSave(theirs);
+    const theirTree = await repository.readTree(theirSave.tree);
+    const oursTree = ours
+        ? await repository.readTree((await repository.readSave(ours)).tree)
+        : { format: "cbx-tree", version: 1, files: [] };
+    const mine = byPath(oursTree);
+    const other = byPath(theirTree);
+    if (ours && (ours === theirs || (await isAncestor(repository, theirs, ours)))) {
+        return { kind: "up-to-date" };
+    }
+    const reading = await (0, snapshot_js_1.readFolder)(repository, { store: false, previous: oursTree });
+    /* Unsaved work is never overwritten; only the files a merge changes are checked. */
+    const guard = (touched) => {
+        const blocked = [];
+        for (const file of touched) {
+            const now = reading.files.get(file);
+            if (!now) {
+                if (mine.has(file))
+                    blocked.push(file);
+                continue;
+            }
+            if (!(0, snapshot_js_1.sameFile)(now, mine.get(file)))
+                blocked.push(file);
+        }
+        if (blocked.length) {
+            throw new errors_js_1.UnsavedChanges(blocked.sort(), "Merging", "Save them or put them back first, then merge again.");
+        }
+    };
+    if (!ours || (await isAncestor(repository, ours, theirs))) {
+        const touched = new Set([...mine.keys(), ...other.keys()].filter((file) => !(0, snapshot_js_1.sameFile)(mine.get(file), other.get(file))));
+        guard(touched);
+        const done = await (0, snapshot_js_1.checkout)(repository, reading.files, theirTree, (file) => touched.has(file));
+        await repository.setLineTip(line, theirs);
+        return { kind: "fast-forward", save: theirSave, ...done };
+    }
+    const baseId = await mergeBase(repository, ours, theirs);
+    const base = baseId
+        ? byPath(await repository.readTree((await repository.readSave(baseId)).tree))
+        : new Map();
+    const result = new Map();
+    const conflicts = [];
+    const labels = { ours: `${line} (this history)`, theirs: options.label };
+    const paths = new Set([...base.keys(), ...mine.keys(), ...other.keys()]);
+    for (const file of [...paths].sort()) {
+        const b = base.get(file);
+        const o = mine.get(file);
+        const t = other.get(file);
+        const settled = (entry) => {
+            if (entry)
+                result.set(file, entry);
+        };
+        if ((0, snapshot_js_1.sameFile)(o, t) || (!o && !t)) {
+            settled(o);
+            continue;
+        }
+        if ((0, snapshot_js_1.sameFile)(b, o) || (!b && !o)) {
+            settled(t);
+            continue;
+        }
+        if ((0, snapshot_js_1.sameFile)(b, t) || (!b && !t)) {
+            settled(o);
+            continue;
+        }
+        /* Only the execute bit differs on one side: take the content once, and that bit. */
+        if (o && t && o.sha256 === t.sha256) {
+            settled({ ...o, executable: b && b.executable !== o.executable ? o.executable : t.executable });
+            continue;
+        }
+        if (!o || !t) {
+            /* Changed on one side, deleted on the other: keep the changed file and ask. */
+            settled(o ?? t);
+            conflicts.push({ path: file, kind: o ? "deleted-there" : "deleted-here" });
+            continue;
+        }
+        const tooBig = Math.max(o.size, t.size, b?.size ?? 0) > TEXT_LIMIT;
+        const ourBytes = tooBig ? null : await (0, snapshot_js_1.contentsOf)(repository, o);
+        const theirBytes = tooBig ? null : await (0, snapshot_js_1.contentsOf)(repository, t);
+        const baseBytes = tooBig || !b ? Buffer.alloc(0) : await (0, snapshot_js_1.contentsOf)(repository, b);
+        if (!ourBytes || !theirBytes || looksBinary(ourBytes) || looksBinary(theirBytes) || looksBinary(baseBytes)) {
+            settled(o);
+            conflicts.push({ path: file, kind: "binary" });
+            continue;
+        }
+        const merged = (0, merge_text_js_1.mergeText)(baseBytes.toString("utf8"), ourBytes.toString("utf8"), theirBytes.toString("utf8"), labels);
+        const text = merged?.text ?? (`<<<<<<< ${labels.ours}\n${ourBytes.toString("utf8")}\n=======\n${theirBytes.toString("utf8")}\n>>>>>>> ${labels.theirs}\n`);
+        const bytes = Buffer.from(text, "utf8");
+        const digest = await repository.objects.put(bytes);
+        settled({
+            path: file,
+            size: bytes.length,
+            sha256: digest,
+            executable: o.executable,
+            chunks: bytes.length ? [digest] : [],
+        });
+        if (!merged || merged.conflicts)
+            conflicts.push({ path: file, kind: "text" });
+    }
+    await repository.objects.flush();
+    const mergedTree = { format: "cbx-tree", version: 1, files: [...result.values()] };
+    const touched = new Set([...mine.keys(), ...result.keys()].filter((file) => !(0, snapshot_js_1.sameFile)(mine.get(file), result.get(file))));
+    guard(touched);
+    const done = await (0, snapshot_js_1.checkout)(repository, reading.files, mergedTree, (file) => touched.has(file));
+    if (conflicts.length) {
+        const state = {
+            format: "cbx-merge",
+            version: 1,
+            theirs,
+            base: baseId,
+            message: options.message,
+            touched: [...touched].sort(),
+            conflicts,
+        };
+        await writeMergeState(repository, state);
+        return { kind: "conflicts", state, ...done };
+    }
+    const tree = await repository.writeTree(mergedTree.files);
+    const save = await repository.writeSave({
+        format: "cbx-save",
+        version: 1,
+        tree,
+        parents: [ours, theirs],
+        line,
+        message: options.message,
+        author: options.author,
+        created: (options.now ?? new Date()).toISOString(),
+    });
+    await repository.setLineTip(line, save.id);
+    /* The files just written are racy; the next status reads them again, once. */
+    return { kind: "merged", save, ...done };
+}
+/** Conflicted text files that still carry markers in the folder. */
+async function unresolved(repository, state) {
+    const left = [];
+    for (const conflict of state.conflicts) {
+        if (conflict.kind !== "text")
+            continue;
+        try {
+            const text = await (0, promises_1.readFile)(node_path_1.default.join(repository.root, conflict.path), "utf8");
+            if ((0, merge_diff_js_1.hasConflictMarkers)(text))
+                left.push(conflict.path);
+        }
+        catch {
+            /* Deleted is a decision too. */
+        }
+    }
+    return left;
+}
+/** Settle conflicted files by taking one side whole. */
+async function takeSide(repository, side, only) {
+    const state = await readMergeState(repository);
+    if (!state)
+        throw new Error("No merge is waiting on conflicts.");
+    const source = side === "mine" ? await repository.head() : state.theirs;
+    const tree = source
+        ? await repository.readTree((await repository.readSave(source)).tree)
+        : { format: "cbx-tree", version: 1, files: [] };
+    const wanted = new Set(state.conflicts.map((one) => one.path).filter((file) => !only || only(file)));
+    if (!wanted.size)
+        throw new Error("None of the conflicts is at that path.");
+    const reading = await (0, snapshot_js_1.readFolder)(repository, { store: false, previous: tree });
+    await (0, snapshot_js_1.checkout)(repository, reading.files, tree, (file) => wanted.has(file));
+    /* A side that does not hold the file settles it by removing it. */
+    for (const file of wanted) {
+        if (!tree.files.some((entry) => entry.path === file)) {
+            await (0, promises_1.rm)(node_path_1.default.join(repository.root, file), { force: true });
+        }
+    }
+    state.conflicts = state.conflicts.filter((one) => !wanted.has(one.path));
+    await writeMergeState(repository, state);
+    return [...wanted].sort();
+}

package/dist/cbx/src/local/merge_text.js

@@ -0,0 +1,148 @@
+"use strict";
+/**
+ * A three-way merge of text: what two people did to the same starting point.
+ *
+ * The shared diff in `shared/merge_diff` compares two sides, which is all a
+ * conflict on CodeRook needs because the service already knows the base. A
+ * local merge has the base too, and using it is the whole difference between
+ * a merge and a comparison: a line only one side touched is taken without
+ * asking, and only a line both sides changed differently is a conflict.
+ *
+ * Lines keep their own endings, so a file with CRLF endings comes out with
+ * CRLF endings, and nothing is normalised that nobody asked to change.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.splitLines = splitLines;
+exports.mergeText = mergeText;
+/*
+  The most comparison cells one line match may fill. The match is an exact
+  longest-common-subsequence, quadratic in the lines that differ once the
+  shared start and end are set aside; past this the file is not merged line
+  by line and is reported as a conflict instead.
+*/
+const CELL_LIMIT = 16_000_000;
+/** Lines with their endings, so joining them gives back the exact text. */
+function splitLines(text) {
+    if (!text)
+        return [];
+    return text.split(/(?<=\n)/);
+}
+/**
+ * For each line of `from`, the line of `to` it is matched with, or -1.
+ * Null when the files differ too widely to match affordably.
+ */
+function match(from, to) {
+    const matched = new Int32Array(from.length).fill(-1);
+    let start = 0;
+    while (start < from.length && start < to.length && from[start] === to[start]) {
+        matched[start] = start;
+        start += 1;
+    }
+    let end = 0;
+    while (end < from.length - start &&
+        end < to.length - start &&
+        from[from.length - 1 - end] === to[to.length - 1 - end]) {
+        matched[from.length - 1 - end] = to.length - 1 - end;
+        end += 1;
+    }
+    const rows = from.length - start - end;
+    const columns = to.length - start - end;
+    if (!rows || !columns)
+        return matched;
+    if ((rows + 1) * (columns + 1) > CELL_LIMIT)
+        return null;
+    /* Suffix table: table[a][b] is the LCS length of from[a..] and to[b..]. */
+    const width = columns + 1;
+    const table = new Uint32Array((rows + 1) * width);
+    for (let a = rows - 1; a >= 0; a -= 1) {
+        for (let b = columns - 1; b >= 0; b -= 1) {
+            table[a * width + b] =
+                from[start + a] === to[start + b]
+                    ? table[(a + 1) * width + b + 1] + 1
+                    : Math.max(table[(a + 1) * width + b], table[a * width + b + 1]);
+        }
+    }
+    let a = 0;
+    let b = 0;
+    while (a < rows && b < columns) {
+        if (from[start + a] === to[start + b]) {
+            matched[start + a] = start + b;
+            a += 1;
+            b += 1;
+        }
+        else if (table[(a + 1) * width + b] >= table[a * width + b + 1]) {
+            a += 1;
+        }
+        else {
+            b += 1;
+        }
+    }
+    return matched;
+}
+const same = (left, right) => left.length === right.length && left.every((line, at) => line === right[at]);
+/**
+ * Merge `ours` and `theirs`, both descended from `base`.
+ *
+ * Null when the files are too different to match line by line; the caller
+ * treats the whole file as one conflict.
+ */
+function mergeText(base, ours, theirs, labels = { ours: "ours", theirs: "theirs" }) {
+    const o = splitLines(base);
+    const a = splitLines(ours);
+    const b = splitLines(theirs);
+    const toA = match(o, a);
+    const toB = match(o, b);
+    if (!toA || !toB)
+        return null;
+    const eol = ours.includes("\r\n") ? "\r\n" : "\n";
+    const out = [];
+    let conflicts = 0;
+    let i = 0;
+    let j = 0;
+    let k = 0;
+    const settle = (baseSlice, oursSlice, theirsSlice) => {
+        if (same(oursSlice, baseSlice))
+            out.push(...theirsSlice);
+        else if (same(theirsSlice, baseSlice))
+            out.push(...oursSlice);
+        else if (same(oursSlice, theirsSlice))
+            out.push(...oursSlice);
+        else {
+            conflicts += 1;
+            /* A side that ends without a newline would run into the marker. */
+            const ended = (lines) => {
+                const copy = [...lines];
+                const last = copy[copy.length - 1];
+                if (last !== undefined && !last.endsWith("\n"))
+                    copy[copy.length - 1] = last + eol;
+                return copy;
+            };
+            out.push(`<<<<<<< ${labels.ours}${eol}`, ...ended(oursSlice), `=======${eol}`);
+            out.push(...ended(theirsSlice), `>>>>>>> ${labels.theirs}${eol}`);
+        }
+    };
+    for (;;) {
+        /* The next base line both sides kept, at or after where we are. */
+        let stable = i;
+        while (stable < o.length && (toA[stable] < j || toB[stable] < k))
+            stable += 1;
+        if (stable === o.length) {
+            settle(o.slice(i), a.slice(j), b.slice(k));
+            break;
+        }
+        const nextA = toA[stable];
+        const nextB = toB[stable];
+        if (stable === i && nextA === j && nextB === k) {
+            out.push(o[i]);
+            i += 1;
+            j += 1;
+            k += 1;
+            continue;
+        }
+        settle(o.slice(i, stable), a.slice(j, nextA), b.slice(k, nextB));
+        i = stable;
+        j = nextA;
+        k = nextB;
+    }
+    return { text: out.join(""), conflicts };
+}