@coderook/cli 0.31.13 → 0.32.0

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

@@ -0,0 +1,522 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnsavedChanges = exports.UnresolvedConflicts = exports.Repository = void 0;
+exports.compareTrees = compareTrees;
+exports.byPath = byPath;
+exports.changeCount = changeCount;
+exports.pathFilter = pathFilter;
+exports.headTree = headTree;
+exports.init = init;
+exports.save = save;
+exports.log = log;
+exports.status = status;
+exports.diff = diff;
+exports.lineDiff = lineDiff;
+exports.inTheWay = inTheWay;
+exports.hiddenInTheWay = hiddenInTheWay;
+exports.restore = restore;
+exports.switchLine = switchLine;
+exports.merge = merge;
+exports.cancelMerge = cancelMerge;
+exports.resolveConflicts = resolveConflicts;
+/**
+ * What `cbx init`, `save`, `log`, `status`, `diff`, `restore` and `switch` do,
+ * without the printing. Everything here works with no network at all.
+ */
+const node_crypto_1 = require("node:crypto");
+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 repository_js_1 = require("./repository.js");
+const snapshot_js_1 = require("./snapshot.js");
+const errors_js_1 = require("./errors.js");
+const merge_js_1 = require("./merge.js");
+var repository_js_2 = require("./repository.js");
+Object.defineProperty(exports, "Repository", { enumerable: true, get: function () { return repository_js_2.Repository; } });
+var errors_js_2 = require("./errors.js");
+Object.defineProperty(exports, "UnresolvedConflicts", { enumerable: true, get: function () { return errors_js_2.UnresolvedConflicts; } });
+Object.defineProperty(exports, "UnsavedChanges", { enumerable: true, get: function () { return errors_js_2.UnsavedChanges; } });
+const EMPTY_TREE = { format: "cbx-tree", version: 1, files: [] };
+/** Past this a file is described, not diffed line by line. */
+const DIFF_BYTE_LIMIT = 4 * 1024 * 1024;
+function compareTrees(before, after) {
+    const changes = { added: [], modified: [], deleted: [] };
+    for (const [file, entry] of after) {
+        const was = before.get(file);
+        if (!was)
+            changes.added.push(file);
+        else if (!(0, snapshot_js_1.sameFile)(was, entry))
+            changes.modified.push(file);
+    }
+    for (const file of before.keys())
+        if (!after.has(file))
+            changes.deleted.push(file);
+    for (const list of Object.values(changes))
+        list.sort();
+    return changes;
+}
+function byPath(tree) {
+    return new Map(tree.files.map((file) => [file.path, file]));
+}
+function changeCount(changes) {
+    return changes.added.length + changes.modified.length + changes.deleted.length;
+}
+/**
+ * A filter for paths the user named, relative to the history's root.
+ *
+ * A name matches itself and everything under it, so naming a folder names
+ * its contents. `.` or the root itself names everything.
+ */
+function pathFilter(repository, names, cwd = process.cwd()) {
+    if (!names.length)
+        return undefined;
+    const wanted = names.map((name) => {
+        const relative = node_path_1.default
+            .relative(repository.root, node_path_1.default.resolve(cwd, name))
+            .split(node_path_1.default.sep)
+            .join("/");
+        if (relative.startsWith("..") || node_path_1.default.isAbsolute(relative)) {
+            throw new Error(`${name} is outside this project.`);
+        }
+        return relative;
+    });
+    if (wanted.some((one) => one === ""))
+        return undefined;
+    return (file) => wanted.some((one) => file === one || file.startsWith(`${one}/`));
+}
+async function headTree(repository) {
+    const head = await repository.head();
+    if (!head)
+        return { save: null, tree: EMPTY_TREE };
+    const save = await repository.readSave(head);
+    return { save, tree: await repository.readTree(save.tree) };
+}
+/* ---- init ------------------------------------------------------------ */
+async function init(root, line = repository_js_1.DEFAULT_LINE) {
+    return repository_js_1.Repository.init(root, line);
+}
+/**
+ * Record the folder as it is now, on the current line.
+ *
+ * A save identical to the last one is refused rather than made, because a
+ * history of saves that each say nothing happened is noise.
+ */
+async function save(repository, options) {
+    return repository.locked(async () => {
+        /*
+          A merge waiting on conflicts is finished by saving: the save gets both
+          parents, may say nothing new (keeping one side whole is a decision), and
+          takes the merge's own message when given none.
+        */
+        const merging = await (0, merge_js_1.readMergeState)(repository);
+        const message = options.message.trim() || merging?.message || "";
+        if (!message)
+            throw new Error("A save needs a message saying what changed.");
+        if (merging && !options.force) {
+            const left = await (0, merge_js_1.unresolved)(repository, merging);
+            if (left.length)
+                throw new errors_js_1.UnresolvedConflicts(left);
+        }
+        const { save: parent, tree: before } = await headTree(repository);
+        const reading = await (0, snapshot_js_1.readFolder)(repository, {
+            store: true,
+            previous: before,
+            progress: options.progress,
+        });
+        const tree = await repository.writeTree([...reading.files.values()]);
+        await repository.writeIndex(reading.index);
+        if (!merging && parent && parent.tree === tree) {
+            return { saved: false, reason: "unchanged" };
+        }
+        const line = await repository.currentLine();
+        const parents = parent ? [parent.id] : [];
+        if (merging)
+            parents.push(merging.theirs);
+        const made = await repository.writeSave({
+            format: "cbx-save",
+            version: 1,
+            tree,
+            parents,
+            line,
+            message,
+            author: options.author ?? (await repository.author()),
+            created: (options.now ?? new Date()).toISOString(),
+        });
+        await repository.setLineTip(line, made.id);
+        if (merging)
+            await (0, merge_js_1.clearMergeState)(repository);
+        let bytes = 0;
+        for (const file of reading.files.values())
+            bytes += file.size;
+        return {
+            saved: true,
+            save: made,
+            changes: compareTrees(byPath(before), reading.files),
+            files: reading.files.size,
+            bytes,
+        };
+    });
+}
+/* ---- log ------------------------------------------------------------- */
+/** Saves newest first, following each save's first parent. */
+async function log(repository, options = {}) {
+    const limit = options.limit ?? Infinity;
+    const found = [];
+    let at;
+    if (options.from) {
+        at = await repository.resolve(options.from);
+    }
+    else {
+        const head = await repository.head();
+        at = head ? await repository.readSave(head) : null;
+    }
+    while (at && found.length < limit) {
+        found.push(at);
+        const parent = at.parents[0];
+        at = parent ? await repository.readSave(parent) : null;
+    }
+    return found;
+}
+async function status(repository) {
+    const { save: head, tree } = await headTree(repository);
+    const reading = await (0, snapshot_js_1.readFolder)(repository, { store: false, previous: tree });
+    /*
+      Kept, so the next status does not hash the same files again. The index
+      is only a cache: an entry this writes without objects makes a save read
+      that file once more, never trust something it has not stored.
+    */
+    await repository.writeIndex(reading.index);
+    const merging = await (0, merge_js_1.readMergeState)(repository);
+    return {
+        line: await repository.currentLine(),
+        head,
+        changes: compareTrees(byPath(tree), reading.files),
+        ...(merging
+            ? {
+                merging: {
+                    theirs: merging.theirs,
+                    conflicts: merging.conflicts,
+                    unresolved: await (0, merge_js_1.unresolved)(repository, merging),
+                },
+            }
+            : {}),
+    };
+}
+function looksBinary(bytes) {
+    return bytes.subarray(0, 8192).includes(0);
+}
+/**
+ * What changed between two states of the project.
+ *
+ * `from` defaults to the last save and `to` to the folder as it is, so with
+ * neither it answers "what have I changed since I last saved".
+ */
+async function diff(repository, options = {}) {
+    try {
+        return await diffBetween(repository, options);
+    }
+    finally {
+        await repository.objects.release();
+    }
+}
+async function diffBetween(repository, options) {
+    const beforeTree = options.from
+        ? await repository.readTree((await repository.resolve(options.from)).tree)
+        : (await headTree(repository)).tree;
+    const before = byPath(beforeTree);
+    let after;
+    let afterIsFolder = false;
+    if (options.to) {
+        after = byPath(await repository.readTree((await repository.resolve(options.to)).tree));
+    }
+    else {
+        after = (await (0, snapshot_js_1.readFolder)(repository, { store: false, previous: beforeTree })).files;
+        afterIsFolder = true;
+    }
+    const bytesOf = async (entry, fromFolder) => fromFolder
+        ? (0, promises_1.readFile)(node_path_1.default.join(repository.root, entry.path))
+        : (0, snapshot_js_1.contentsOf)(repository, entry);
+    const changes = compareTrees(before, after);
+    const results = [];
+    const kinds = [
+        ["added", changes.added],
+        ["modified", changes.modified],
+        ["deleted", changes.deleted],
+    ];
+    const ordered = kinds
+        .flatMap(([kind, files]) => files.map((file) => ({ kind, file })))
+        .filter(({ file }) => !options.only || options.only(file))
+        .sort((left, right) => (left.file < right.file ? -1 : left.file > right.file ? 1 : 0));
+    for (const { kind, file } of ordered) {
+        const was = before.get(file);
+        const now = after.get(file);
+        const result = { path: file, kind };
+        if (was && now && was.sha256 === now.sha256) {
+            result.executableChanged = true;
+            result.chunks = [];
+            results.push(result);
+            continue;
+        }
+        const size = Math.max(was?.size ?? 0, now?.size ?? 0);
+        if (size > DIFF_BYTE_LIMIT) {
+            result.summary = `${describeSize(was?.size)} → ${describeSize(now?.size)}, too large to show line by line`;
+            results.push(result);
+            continue;
+        }
+        const left = was ? await bytesOf(was, false) : Buffer.alloc(0);
+        const right = now ? await bytesOf(now, afterIsFolder) : Buffer.alloc(0);
+        if (looksBinary(left) || looksBinary(right)) {
+            result.summary = `binary, ${describeSize(was?.size)} → ${describeSize(now?.size)}`;
+            results.push(result);
+            continue;
+        }
+        if (was && now)
+            result.executableChanged = was.executable !== now.executable;
+        const lines = lineDiff(left.toString("utf8"), right.toString("utf8"));
+        if (!lines) {
+            result.summary = "too many lines changed to show line by line";
+            results.push(result);
+            continue;
+        }
+        result.chunks = (0, merge_diff_js_1.foldUnchanged)(lines, options.context ?? 3);
+        results.push(result);
+    }
+    return results;
+}
+/*
+  The most comparison cells the line diff may fill.
+
+  The shared diff is an exact longest-common-subsequence table, which is the
+  right call for a merge conflict and quadratic in memory. Lines both sides
+  share at the start and end are taken off first, so an ordinary edit costs
+  almost nothing; past this, the change is described instead.
+*/
+const DIFF_CELL_LIMIT = 4_000_000;
+/** Lines in order, or null when the files differ too widely to compare. */
+function lineDiff(before, after) {
+    const left = (0, merge_diff_js_1.linesOf)(before);
+    const right = (0, merge_diff_js_1.linesOf)(after);
+    let start = 0;
+    while (start < left.length && start < right.length && left[start] === right[start])
+        start += 1;
+    let end = 0;
+    while (end < left.length - start &&
+        end < right.length - start &&
+        left[left.length - 1 - end] === right[right.length - 1 - end]) {
+        end += 1;
+    }
+    const middleLeft = left.slice(start, left.length - end);
+    const middleRight = right.slice(start, right.length - end);
+    if ((middleLeft.length + 1) * (middleRight.length + 1) > DIFF_CELL_LIMIT)
+        return null;
+    const same = (a, b) => ({
+        side: "same",
+        targetLine: a + 1,
+        candidateLine: b + 1,
+        text: left[a],
+    });
+    const out = [];
+    for (let at = 0; at < start; at += 1)
+        out.push(same(at, at));
+    /* Every line newline-ended, so an empty line survives the round trip. */
+    const joined = (lines) => lines.map((line) => `${line}\n`).join("");
+    for (const line of (0, merge_diff_js_1.diffLines)(joined(middleLeft), joined(middleRight))) {
+        out.push({
+            ...line,
+            targetLine: line.targetLine === null ? null : line.targetLine + start,
+            candidateLine: line.candidateLine === null ? null : line.candidateLine + start,
+        });
+    }
+    for (let at = 0; at < end; at += 1) {
+        out.push(same(left.length - end + at, right.length - end + at));
+    }
+    return out;
+}
+function describeSize(size) {
+    if (size === undefined)
+        return "nothing";
+    if (size < 1024)
+        return `${size} B`;
+    if (size < 1024 * 1024)
+        return `${(size / 1024).toFixed(1)} KB`;
+    return `${(size / 1024 / 1024).toFixed(1)} MB`;
+}
+/* ---- restore and switch ---------------------------------------------- */
+/**
+ * Unsaved changes among the files a checkout will rewrite or delete.
+ *
+ * A file that is missing from the folder is never in the way: putting it
+ * back loses nothing. Nor is one that already holds what the checkout would
+ * write. Anything else that differs from the last save would be lost.
+ */
+function inTheWay(current, head, target, touched) {
+    const blocked = [];
+    for (const file of touched) {
+        const now = current.get(file);
+        if (!now)
+            continue;
+        if ((0, snapshot_js_1.sameFile)(now, head.get(file)) || (0, snapshot_js_1.sameFile)(now, target.get(file)))
+            continue;
+        blocked.push(file);
+    }
+    return blocked.sort();
+}
+/**
+ * Files the checkout would write over that the folder reading never saw.
+ *
+ * The reading lists only what the ignore rules let through, so a file the
+ * rules now leave out but a save still holds would be written over with no
+ * check at all. Those are looked at on disk directly.
+ */
+async function hiddenInTheWay(repository, current, target, touched) {
+    const blocked = [];
+    const unseen = [...touched].filter((file) => target.has(file) && !current.has(file));
+    await (0, snapshot_js_1.inLanes)(unseen, 16, async (file) => {
+        let bytes;
+        try {
+            bytes = await (0, promises_1.readFile)(node_path_1.default.join(repository.root, file));
+        }
+        catch {
+            return;
+        }
+        if ((0, node_crypto_1.createHash)("sha256").update(bytes).digest("hex") !== target.get(file).sha256) {
+            blocked.push(file);
+        }
+    });
+    return blocked;
+}
+/**
+ * Put files back the way a save had them. The line does not move: this
+ * changes the folder, and the next save records whatever it now holds.
+ */
+async function restore(repository, options = {}) {
+    return repository.locked(async () => {
+        const source = await repository.resolve(options.from ?? "HEAD");
+        const target = await repository.readTree(source.tree);
+        const { tree: headSaved } = await headTree(repository);
+        const reading = await (0, snapshot_js_1.readFolder)(repository, { store: false, previous: headSaved });
+        const saved = byPath(headSaved);
+        const wanted = byPath(target);
+        /*
+          Every file either save holds, within the paths named. Files neither
+          holds are none of the history's business and are never touched.
+        */
+        const touched = new Set([...saved.keys(), ...wanted.keys()].filter((file) => !options.only || options.only(file)));
+        if (!options.force) {
+            const blocked = [
+                ...inTheWay(reading.files, saved, wanted, touched),
+                ...(await hiddenInTheWay(repository, reading.files, wanted, touched)),
+            ].sort();
+            if (blocked.length)
+                throw new errors_js_1.UnsavedChanges(blocked, "Restoring");
+        }
+        /*
+          Compared with what is on disk, not what was saved, so a file with
+          unsaved changes is rewritten and one that already matches is not.
+        */
+        const done = await (0, snapshot_js_1.checkout)(repository, reading.files, target, (file) => touched.has(file));
+        return { save: source, ...done };
+    });
+}
+/**
+ * Move the folder to another line of work, or start one with `create`.
+ *
+ * A new line begins at the current save and changes no files. Moving to an
+ * existing line rewrites only the files that differ between the two, and
+ * unsaved changes to those files stop it unless `force` is given.
+ */
+async function switchLine(repository, line, options = {}) {
+    const problem = (0, repository_js_1.lineNameProblem)(line);
+    if (problem)
+        throw new Error(`Cannot name a line "${line}": ${problem}.`);
+    return repository.locked(async () => {
+        if (await (0, merge_js_1.readMergeState)(repository)) {
+            throw new Error("A merge is waiting on conflicts. Finish it with cbx save, or cancel it with cbx merge --cancel.");
+        }
+        const current = await repository.currentLine();
+        if (options.create) {
+            if (await repository.lineExists(line)) {
+                throw new Error(`There is already a line called ${line}. Leave out -c to switch to it.`);
+            }
+            const head = await repository.head();
+            if (head)
+                await repository.setLineTip(line, head);
+            await repository.setCurrentLine(line);
+            return {
+                line,
+                created: true,
+                save: head ? await repository.readSave(head) : null,
+                written: [],
+                removed: [],
+            };
+        }
+        if (line === current) {
+            throw new Error(`Already on ${line}.`);
+        }
+        const tip = await repository.lineTip(line);
+        if (!tip)
+            throw new Error(`No line called ${line}. Add -c to start one here.`);
+        const targetSave = await repository.readSave(tip);
+        const target = await repository.readTree(targetSave.tree);
+        const { tree: headSaved } = await headTree(repository);
+        const reading = await (0, snapshot_js_1.readFolder)(repository, { store: false, previous: headSaved });
+        const saved = byPath(headSaved);
+        const wanted = byPath(target);
+        /*
+          Only files the two lines disagree about. An edit to a file both lines
+          hold alike comes along to the new line untouched, as it does in git.
+        */
+        const touched = new Set([...saved.keys(), ...wanted.keys()].filter((file) => !(0, snapshot_js_1.sameFile)(saved.get(file), wanted.get(file))));
+        if (!options.force) {
+            const blocked = [
+                ...inTheWay(reading.files, saved, wanted, touched),
+                ...(await hiddenInTheWay(repository, reading.files, wanted, touched)),
+            ].sort();
+            if (blocked.length)
+                throw new errors_js_1.UnsavedChanges(blocked, `Switching to ${line}`);
+        }
+        const done = await (0, snapshot_js_1.checkout)(repository, reading.files, target, (file) => touched.has(file));
+        await repository.setCurrentLine(line);
+        return { line, created: false, save: targetSave, ...done };
+    });
+}
+/* ---- merge ------------------------------------------------------------ */
+/**
+ * Merge another line, or any save, into the folder's line.
+ *
+ * Moves the line straight to it when this line has nothing of its own, and
+ * does nothing when it is already included. Otherwise see merge.ts.
+ */
+async function merge(repository, other, options = {}) {
+    return repository.locked(async () => {
+        const theirs = await repository.resolve(other);
+        const line = await repository.currentLine();
+        return (0, merge_js_1.mergeInto)(repository, theirs.id, {
+            message: options.message?.trim() || `Merge ${other} into ${line}`,
+            author: options.author ?? (await repository.author()),
+            label: other,
+            now: options.now,
+        });
+    });
+}
+/** Call a waiting merge off and put back every file it changed. */
+async function cancelMerge(repository) {
+    return repository.locked(async () => {
+        const state = await (0, merge_js_1.readMergeState)(repository);
+        if (!state)
+            throw new Error("No merge is waiting.");
+        const { tree } = await headTree(repository);
+        const touched = new Set(state.touched);
+        const reading = await (0, snapshot_js_1.readFolder)(repository, { store: false, previous: tree });
+        const done = await (0, snapshot_js_1.checkout)(repository, reading.files, tree, (file) => touched.has(file));
+        await (0, merge_js_1.clearMergeState)(repository);
+        return [...done.written, ...done.removed].sort();
+    });
+}
+/** Settle conflicts by taking this line's side or the other's, whole. */
+async function resolveConflicts(repository, side, only) {
+    return repository.locked(() => (0, merge_js_1.takeSide)(repository, side, only));
+}