@coderook/cli 0.46.1 → 0.46.3

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

@@ -0,0 +1,269 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.V2IndexFile = exports.V2_PACK_BYTES = exports.MAX_CHAIN = exports.LARGE_WINDOW_LOG = exports.LARGE_BLOCK_BYTES = exports.SOLID_BLOCK_BYTES = exports.SOLID_OBJECT_LIMIT = exports.KIND_DELTA_ZSTD = exports.KIND_DELTA = exports.KIND_SOLID = exports.KIND_WHOLE_ZSTD = exports.KIND_WHOLE = void 0;
+exports.zstdAt = zstdAt;
+exports.compresses = compresses;
+exports.unzstd = unzstd;
+exports.encodeIndex = encodeIndex;
+exports.decodeIndex = decodeIndex;
+exports.solidKey = solidKey;
+exports.sha256Hex = sha256Hex;
+/**
+ * How a cbx-local 2 history keeps objects on disk (engine/V2-STORE.md).
+ *
+ * A v2 history holds exactly the objects a v1 history holds, under the same
+ * names; only the way each is kept changes. A v2 pack is a run of records,
+ * each one of:
+ *
+ *   whole    the object's bytes, as they are or zstd-compressed
+ *   solid    many small objects joined and compressed as one block, so what
+ *            files share (licence headers, imports, near-copies) is stored once
+ *   delta    an exact COPY/INSERT patch (CRP2, the format the service applies)
+ *            against another object, as it is or zstd-compressed
+ *
+ * Every object read is rebuilt and checked against its name before it is
+ * used, delta bases included, so damage anywhere is refused rather than
+ * passed on.
+ *
+ *   .cbx/objects/v2/<id>.pack   records, written whole then renamed
+ *   .cbx/objects/v2/<id>.idx    binary index, sorted by name with a fan-out
+ */
+const node_crypto_1 = require("node:crypto");
+const node_zlib_1 = require("node:zlib");
+exports.KIND_WHOLE = 1;
+exports.KIND_WHOLE_ZSTD = 2;
+exports.KIND_SOLID = 3;
+exports.KIND_DELTA = 4;
+exports.KIND_DELTA_ZSTD = 5;
+/** Objects at most this big wait to be joined into a solid block. */
+exports.SOLID_OBJECT_LIMIT = 256 * 1024;
+/** A solid block of small objects holds this much before it is compressed. */
+exports.SOLID_BLOCK_BYTES = 16 * 1024 * 1024;
+/*
+  Larger objects that compress are joined too, in bigger blocks with a window
+  as big as the block, so one program can be kept as what it shares with
+  another: CMake's fourteen largest files took 31.96 MB compressed one by one
+  and 23.89 MB together. Git finds the same thing with its deltas after gc.
+*/
+exports.LARGE_BLOCK_BYTES = 64 * 1024 * 1024;
+exports.LARGE_WINDOW_LOG = 26;
+/** A delta may stand on at most this many others; past that the object is kept whole. */
+exports.MAX_CHAIN = 12;
+/** A pack is written once the objects waiting for it reach this much. */
+exports.V2_PACK_BYTES = 128 * 1024 * 1024;
+function zstdAt(raw, level, long = false, windowLog, checksum = false) {
+    return (0, node_zlib_1.zstdCompressSync)(raw, {
+        params: {
+            [node_zlib_1.constants.ZSTD_c_compressionLevel]: level,
+            ...(long ? { [node_zlib_1.constants.ZSTD_c_enableLongDistanceMatching]: 1 } : {}),
+            ...(windowLog ? { [node_zlib_1.constants.ZSTD_c_windowLog]: windowLog } : {}),
+            /*
+              Blocks carry zstd's own checksum: four bytes, and damage to a block is
+              refused as damage even where it happens not to change the bytes. The
+              digest of every object read is checked either way.
+            */
+            ...(checksum ? { [node_zlib_1.constants.ZSTD_c_checksumFlag]: 1 } : {}),
+        },
+    });
+}
+/** Whether bytes are worth compressing, judged from a 64 KiB sample of their middle. */
+function compresses(raw) {
+    const sample = raw.length > 131072 ? raw.subarray((raw.length >> 1) - 32768, (raw.length >> 1) + 32768) : raw;
+    return zstdAt(sample, 1).length < sample.length * 0.92;
+}
+function unzstd(stored) {
+    return (0, node_zlib_1.zstdDecompressSync)(stored);
+}
+const INDEX_MAGIC = Buffer.from("CBXI", "latin1");
+const INDEX_VERSION = 2;
+const ENTRY_BYTES = 32 + 1 + 1 + 4 + 4 + 4 + 4;
+const FANOUT = 256;
+/* Below this many entries the fan-out table costs more than it saves, and is left out. */
+const FANOUT_FROM = 1024;
+const FLAG_FANOUT = 1;
+/**
+ * The index of one v2 pack: a 16-byte header, a 256-entry fan-out by first
+ * byte (as Git's pack index has) when there are enough entries to need one,
+ * fixed 50-byte entries sorted by name, and the names delta bases refer to,
+ * once each. A delta's `inner` field is the position of its base in that
+ * table.
+ */
+function encodeIndex(entries) {
+    const names = [...entries.keys()].sort();
+    const bases = [];
+    const baseAt = new Map();
+    for (const name of names) {
+        const base = entries.get(name).base;
+        if (base && !baseAt.has(base)) {
+            baseAt.set(base, bases.length);
+            bases.push(base);
+        }
+    }
+    const fanout = names.length >= FANOUT_FROM;
+    const entriesAt = 16 + (fanout ? FANOUT * 4 : 0);
+    const out = Buffer.alloc(entriesAt + names.length * ENTRY_BYTES + bases.length * 32);
+    INDEX_MAGIC.copy(out, 0);
+    out.writeUInt8(INDEX_VERSION, 4);
+    out.writeUInt8(fanout ? FLAG_FANOUT : 0, 5);
+    out.writeUInt32LE(names.length, 8);
+    out.writeUInt32LE(bases.length, 12);
+    if (fanout) {
+        const counts = new Array(FANOUT).fill(0);
+        for (const name of names)
+            counts[Number.parseInt(name.slice(0, 2), 16)] += 1;
+        let running = 0;
+        for (let byte = 0; byte < FANOUT; byte += 1) {
+            running += counts[byte];
+            out.writeUInt32LE(running, 16 + byte * 4);
+        }
+    }
+    let at = entriesAt;
+    for (const name of names) {
+        const entry = entries.get(name);
+        Buffer.from(name, "hex").copy(out, at);
+        out.writeUInt8(entry.kind, at + 32);
+        out.writeUInt8(entry.chain, at + 33);
+        out.writeUInt32LE(entry.offset, at + 34);
+        out.writeUInt32LE(entry.length, at + 38);
+        out.writeUInt32LE(entry.base ? baseAt.get(entry.base) : entry.inner, at + 42);
+        out.writeUInt32LE(entry.raw, at + 46);
+        at += ENTRY_BYTES;
+    }
+    for (const base of bases) {
+        Buffer.from(base, "hex").copy(out, at);
+        at += 32;
+    }
+    return out;
+}
+function decodeIndex(bytes) {
+    if (bytes.length < 16 || !bytes.subarray(0, 4).equals(INDEX_MAGIC)) {
+        throw new Error("A v2 pack index is damaged");
+    }
+    if (bytes.readUInt8(4) !== INDEX_VERSION)
+        throw new Error("A v2 pack index is of a version this cbx does not read");
+    const count = bytes.readUInt32LE(8);
+    const baseCount = bytes.readUInt32LE(12);
+    const entriesAt = 16 + ((bytes.readUInt8(5) & FLAG_FANOUT) !== 0 ? FANOUT * 4 : 0);
+    const basesAt = entriesAt + count * ENTRY_BYTES;
+    if (bytes.length !== basesAt + baseCount * 32)
+        throw new Error("A v2 pack index is damaged");
+    const bases = [];
+    for (let index = 0; index < baseCount; index += 1) {
+        bases.push(bytes.subarray(basesAt + index * 32, basesAt + index * 32 + 32).toString("hex"));
+    }
+    const entries = new Map();
+    for (let index = 0; index < count; index += 1) {
+        const at = entriesAt + index * ENTRY_BYTES;
+        const kind = bytes.readUInt8(at + 32);
+        const inner = bytes.readUInt32LE(at + 42);
+        const delta = kind === exports.KIND_DELTA || kind === exports.KIND_DELTA_ZSTD;
+        if (delta && inner >= baseCount)
+            throw new Error("A v2 pack index is damaged");
+        entries.set(bytes.subarray(at, at + 32).toString("hex"), {
+            kind,
+            chain: bytes.readUInt8(at + 33),
+            offset: bytes.readUInt32LE(at + 34),
+            length: bytes.readUInt32LE(at + 38),
+            inner: delta ? 0 : inner,
+            raw: bytes.readUInt32LE(at + 46),
+            ...(delta ? { base: bases[inner] } : {}),
+        });
+    }
+    return entries;
+}
+/**
+ * The order small objects are joined in: by extension, then name, so files
+ * of one kind sit together where the compressor can see what they share.
+ */
+function solidKey(filePath) {
+    if (!filePath)
+        return "\u{10ffff}";
+    const name = filePath.slice(filePath.lastIndexOf("/") + 1);
+    const dot = name.lastIndexOf(".");
+    const extension = dot > 0 ? name.slice(dot + 1).toLowerCase() : "";
+    return `${extension}\u0000${name.toLowerCase()}\u0000${filePath}`;
+}
+function sha256Hex(bytes) {
+    return (0, node_crypto_1.createHash)("sha256").update(bytes).digest("hex");
+}
+/**
+ * One v2 index, searched where it lies rather than decoded whole: its
+ * entries are sorted by name, so finding one is a binary search over the
+ * bytes. A status needs a handful of objects, and decoding every entry of
+ * every index into a map of strings was its largest single cost in a v2
+ * history (15 ms of 270 for 8,500 files).
+ */
+class V2IndexFile {
+    pack;
+    count;
+    bytes;
+    entriesAt;
+    basesAt;
+    fanout;
+    baseCount;
+    constructor(pack, bytes) {
+        if (bytes.length < 16 || !bytes.subarray(0, 4).equals(INDEX_MAGIC)) {
+            throw new Error("A v2 pack index is damaged");
+        }
+        if (bytes.readUInt8(4) !== INDEX_VERSION)
+            throw new Error("A v2 pack index is of a version this cbx does not read");
+        this.pack = pack;
+        this.bytes = bytes;
+        this.count = bytes.readUInt32LE(8);
+        this.baseCount = bytes.readUInt32LE(12);
+        this.fanout = (bytes.readUInt8(5) & FLAG_FANOUT) !== 0;
+        this.entriesAt = 16 + (this.fanout ? FANOUT * 4 : 0);
+        this.basesAt = this.entriesAt + this.count * ENTRY_BYTES;
+        if (bytes.length !== this.basesAt + this.baseCount * 32)
+            throw new Error("A v2 pack index is damaged");
+    }
+    find(digest) {
+        const key = Buffer.from(digest, "hex");
+        if (key.length !== 32)
+            return undefined;
+        let low = 0;
+        let high = this.count;
+        if (this.fanout) {
+            const first = key[0];
+            low = first === 0 ? 0 : this.bytes.readUInt32LE(16 + (first - 1) * 4);
+            high = this.bytes.readUInt32LE(16 + first * 4);
+        }
+        while (low < high) {
+            const middle = (low + high) >> 1;
+            const at = this.entriesAt + middle * ENTRY_BYTES;
+            const order = key.compare(this.bytes, at, at + 32);
+            if (order === 0)
+                return this.entryAt(at);
+            if (order < 0)
+                high = middle;
+            else
+                low = middle + 1;
+        }
+        return undefined;
+    }
+    entryAt(at) {
+        const kind = this.bytes.readUInt8(at + 32);
+        const inner = this.bytes.readUInt32LE(at + 42);
+        const delta = kind === exports.KIND_DELTA || kind === exports.KIND_DELTA_ZSTD;
+        if (delta && inner >= this.baseCount)
+            throw new Error("A v2 pack index is damaged");
+        return {
+            kind,
+            chain: this.bytes.readUInt8(at + 33),
+            offset: this.bytes.readUInt32LE(at + 34),
+            length: this.bytes.readUInt32LE(at + 38),
+            inner: delta ? 0 : inner,
+            raw: this.bytes.readUInt32LE(at + 46),
+            ...(delta
+                ? { base: this.bytes.subarray(this.basesAt + inner * 32, this.basesAt + inner * 32 + 32).toString("hex") }
+                : {}),
+        };
+    }
+    *names() {
+        for (let index = 0; index < this.count; index += 1) {
+            const at = this.entriesAt + index * ENTRY_BYTES;
+            yield this.bytes.subarray(at, at + 32).toString("hex");
+        }
+    }
+}
+exports.V2IndexFile = V2IndexFile;

package/dist/cbx/src/shared/delta.js

@@ -18,6 +18,7 @@ exports.deltaBlockSize = deltaBlockSize;
 exports.estimateDeltaSignatureBytes = estimateDeltaSignatureBytes;
 exports.createDeltaSignature = createDeltaSignature;
 exports.parseDeltaSignature = parseDeltaSignature;
+exports.createExactDeltaPatch = createExactDeltaPatch;
 exports.createDeltaPatch = createDeltaPatch;
 exports.deltaPatchTargetSize = deltaPatchTargetSize;
 exports.applyDeltaPatch = applyDeltaPatch;
@@ -313,6 +314,108 @@ function encodePatchV2(targetSize, operations) {
     }
     return out;
 }
+/* Bytes a run must share with the base before it is worth a COPY over a literal. */
+const EXACT_MIN_COPY = 12;
+const EXACT_WINDOW = 16;
+function windowKey(bytes, at) {
+    let hash = 0x811c9dc5;
+    for (let index = 0; index < EXACT_WINDOW; index += 1) {
+        hash = Math.imul(hash ^ (bytes[at + index] ?? 0), 0x01000193);
+    }
+    return hash >>> 0;
+}
+/**
+ * Build a V2 patch from the base bytes themselves, for a client that still
+ * holds the version it is editing, the way Git's sender holds the objects the
+ * receiver has. No signature is fetched, and copies start and end on any
+ * byte, so a one-byte edit costs a few bytes instead of a whole block.
+ *
+ * The result is the same CRP2 format the receiver-signature path produces:
+ * any service that applies those applies this, and verifies the digest after.
+ */
+function createExactDeltaPatch(base, target, 
+/* The transport's limit unless said; a local history keeps larger pieces as deltas too. */
+maxBytes = exports.DELTA_MAX_FILE_BYTES) {
+    if (target.byteLength > maxBytes || base.byteLength > maxBytes) {
+        throw new Error("Delta target exceeds the bounded transport limit");
+    }
+    const operations = [];
+    /* The common case is one edited region: keep both ends whole. */
+    const limit = Math.min(base.byteLength, target.byteLength);
+    let prefix = 0;
+    while (prefix < limit && base[prefix] === target[prefix])
+        prefix += 1;
+    let suffix = 0;
+    while (suffix < limit - prefix &&
+        base[base.byteLength - 1 - suffix] === target[target.byteLength - 1 - suffix])
+        suffix += 1;
+    if (prefix >= EXACT_MIN_COPY)
+        appendOperation(operations, { kind: "copy", offset: 0, length: prefix });
+    else
+        prefix = 0;
+    if (suffix < EXACT_MIN_COPY)
+        suffix = 0;
+    const baseEnd = base.byteLength - suffix;
+    const targetEnd = target.byteLength - suffix;
+    /* Every window of the base's middle, by the offset it starts at. */
+    const index = new Map();
+    /*
+      Every offset for a small middle; every sixteenth past 256 KiB, as Git's
+      delta indexes, so an 8 MiB base is half a million entries, not eight
+      million. The target is still scanned at every byte, so moved text is found.
+    */
+    const middle = baseEnd - prefix;
+    const stride = middle > 8 * 1024 * 1024 ? EXACT_WINDOW * 4 : middle > 256 * 1024 ? EXACT_WINDOW : 1;
+    for (let at = prefix; at + EXACT_WINDOW <= baseEnd; at += stride) {
+        const key = windowKey(base, at);
+        const list = index.get(key);
+        if (!list)
+            index.set(key, [at]);
+        else if (list.length < 16)
+            list.push(at);
+    }
+    let cursor = prefix;
+    let literalStart = prefix;
+    while (cursor + EXACT_WINDOW <= targetEnd) {
+        const candidates = index.get(windowKey(target, cursor));
+        let bestOffset = -1;
+        let bestLength = 0;
+        let bestBack = 0;
+        for (const offset of candidates ?? []) {
+            let length = 0;
+            while (cursor + length < targetEnd &&
+                offset + length < baseEnd &&
+                base[offset + length] === target[cursor + length])
+                length += 1;
+            let back = 0;
+            while (back < cursor - literalStart &&
+                back < offset - prefix &&
+                base[offset - back - 1] === target[cursor - back - 1])
+                back += 1;
+            if (length + back > bestLength + bestBack) {
+                bestOffset = offset;
+                bestLength = length;
+                bestBack = back;
+            }
+        }
+        if (bestOffset >= 0 && bestLength + bestBack >= EXACT_MIN_COPY) {
+            appendOperation(operations, { kind: "literal", bytes: target.slice(literalStart, cursor - bestBack) });
+            appendOperation(operations, {
+                kind: "copy",
+                offset: bestOffset - bestBack,
+                length: bestLength + bestBack,
+            });
+            cursor += bestLength;
+            literalStart = cursor;
+            continue;
+        }
+        cursor += 1;
+    }
+    appendOperation(operations, { kind: "literal", bytes: target.slice(literalStart, targetEnd) });
+    if (suffix)
+        appendOperation(operations, { kind: "copy", offset: baseEnd, length: suffix });
+    return encodePatchV2(target.byteLength, operations);
+}
 /** Build COPY/INSERT operations from receiver signatures, without base bytes. */
 function createDeltaPatch(target, signature) {
     if (target.byteLength > exports.DELTA_MAX_FILE_BYTES) {
@@ -394,9 +497,11 @@ function deltaPatchTargetSize(patch) {
     }
     return size;
 }
-function applyDeltaPatch(base, patch) {
+function applyDeltaPatch(base, patch, 
+/* The transport's limit unless said; see createExactDeltaPatch. */
+maxBytes = exports.DELTA_MAX_FILE_BYTES) {
     if (sameMagic(patch, PATCH_MAGIC_V2)) {
-        return applyDeltaPatchV2(base, patch);
+        return applyDeltaPatchV2(base, patch, maxBytes);
     }
     if (patch.byteLength < PATCH_HEADER_V1_BYTES ||
         !sameMagic(patch, PATCH_MAGIC_V1)) {
@@ -454,12 +559,12 @@ function applyDeltaPatch(base, patch) {
     }
     return out;
 }
-function applyDeltaPatchV2(base, patch) {
+function applyDeltaPatchV2(base, patch, maxBytes = exports.DELTA_MAX_FILE_BYTES) {
     const targetField = readVarUint(patch, 4);
     const targetSize = targetField.value;
     const countField = readVarUint(patch, targetField.next);
     const operationCount = countField.value;
-    if (targetSize > exports.DELTA_MAX_FILE_BYTES || operationCount > 1_000_000) {
+    if (targetSize > maxBytes || operationCount > 1_000_000) {
         throw new Error("Delta patch dimensions are invalid");
     }
     const out = new Uint8Array(targetSize);

package/dist/cbx/src/shared/native_engine.js

@@ -11,6 +11,7 @@ exports.engineStore = engineStore;
 exports.engineMeasure = engineMeasure;
 exports.engineScan = engineScan;
 exports.resetEngineForTests = resetEngineForTests;
+exports.engineQuickStatus = engineQuickStatus;
 /**
  * The native byte engine (cbx/engine, Rust), when there is one.
  *
@@ -287,3 +288,25 @@ function resetEngineForTests() {
     located = undefined;
     broken = null;
 }
+/**
+ * A quiet status answered by the engine alone (engine/src/quick.rs): "clean"
+ * only when a cbx-local 2 history's folder is exactly the line's newest save,
+ * judged from the stamp status leaves in the index and a walk of the folder.
+ * Anything else, and an engine too old to know the command, is null or
+ * "unknown", and the full status answers. Never marks the engine broken: an
+ * older engine still scans for that full status.
+ */
+async function engineQuickStatus(from) {
+    if (!enginePath() || broken || process.env.CBX_ENGINE_QUICK === "off" || !usable())
+        return null;
+    const answer = await run(["quick-status", from], "");
+    if (answer.code !== 0)
+        return null;
+    try {
+        const parsed = JSON.parse(answer.stdout);
+        return parsed.protocol === PROTOCOL ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/cli/src/bin.js

@@ -57,6 +57,27 @@ async function quickStatus() {
         return null;
     if (await (0, reminder_gate_js_1.reminderDue)("status"))
         return null;
+    /*
+      A folder that is exactly its last save is answered by the engine alone,
+      from the stamp the last status left (engine/src/quick.rs): one walk and
+      four small reads, and none of the history code loaded here. Anything it
+      cannot vouch for is answered below as before.
+    */
+    const { engineQuickStatus } = await Promise.resolve().then(() => __importStar(require("../../cbx/src/shared/native_engine.js")));
+    const quick = await engineQuickStatus(process.cwd());
+    if (quick?.answer === "clean" || quick?.answer === "changed") {
+        const { accent, bold, dim, short } = await Promise.resolve().then(() => __importStar(require("./paint.js")));
+        console.log(`${bold(quick.project)} on ${accent(quick.line)}` +
+            dim(`  last saved ${short(quick.head)}: ${quick.message.split("\n")[0]}`));
+        if (quick.answer === "clean") {
+            console.log("Nothing has changed since the last save.");
+        }
+        else {
+            const { printChangedSummary } = await Promise.resolve().then(() => __importStar(require("./status_lines.js")));
+            printChangedSummary({ added: quick.added, modified: quick.modified, deleted: quick.deleted });
+        }
+        return 0;
+    }
     const { Repository } = await Promise.resolve().then(() => __importStar(require("../../cbx/src/local/repository.js")));
     const repository = await Repository.find(process.cwd());
     if (!repository)

package/dist/cli/src/cli.js

@@ -1267,14 +1267,27 @@ Pass ${accent("--allow-secrets")} if these are not real keys.`);
       command now does it itself, a few times, before giving up.
     */
     const resumeAfter = [10, 30, 60];
+    /*
+      The project an attempt created, for the attempts after it. A first save
+      creates its project while planning, and the project stays once anything
+      has been sent so a retry can reuse what arrived; but the retry used to ask
+      to create it again under the same name and was refused, so a dropped
+      connection during a first save could never be picked up.
+    */
+    let createdRepositoryId = null;
     for (let resumed = 0;; resumed += 1) {
         try {
+            if (createdRepositoryId && !uploadRequest.repositoryId) {
+                Object.assign(uploadRequest, { repositoryId: createdRepositoryId });
+            }
             const plan = await uploader.plan(uploadRequest, (progress) => {
                 line(`  ${track(progress.percent)} ${String(progress.percent).padStart(3)}%  ` +
                     `${"plan".padEnd(7)} ${progress.files}/${progress.totalFiles}  ` +
                     dim(progress.path.slice(-40)));
             });
             done(line);
+            if (plan.repositoryCreated)
+                createdRepositoryId = plan.repositoryId;
             console.log(`${accent("Upload plan")}  ${bytes(plan.sourceBytes)} selected → ` +
                 `${bytes(plan.compactedBytes)} compacted; ${bytes(plan.chargeableBytes)} new storage.`);
             console.log(plan.allowance.exempt

package/dist/cli/src/local_status.js

@@ -3,8 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.plural = exports.short = exports.accent = exports.green = exports.red = exports.bold = exports.dim = void 0;
-exports.printChanges = printChanges;
+exports.short = exports.red = exports.printChanges = exports.plural = exports.green = exports.dim = exports.bold = exports.accent = void 0;
 exports.printLocalStatus = printLocalStatus;
 /**
  * What `cbx status` prints in a folder with a local history, kept apart from
@@ -17,37 +16,25 @@ exports.printLocalStatus = printLocalStatus;
  */
 const node_path_1 = __importDefault(require("node:path"));
 const history_js_1 = require("../../cbx/src/local/history.js");
-const ESC = String.fromCharCode(27);
-const paint = (code) => (value) => `${ESC}[${code}m${value}${ESC}[0m`;
-exports.dim = paint("2");
-exports.bold = paint("1");
-exports.red = paint("31");
-exports.green = paint("32");
-exports.accent = paint("33");
-const short = (id) => id.slice(0, 10);
-exports.short = short;
-const plural = (count, one, many = `${one}s`) => `${count.toLocaleString()} ${count === 1 ? one : many}`;
-exports.plural = plural;
-function printChanges(changes, limit = 50) {
-    const rows = [
-        ...changes.added.map((file) => [(0, exports.green)("added   "), file]),
-        ...changes.modified.map((file) => [(0, exports.accent)("changed "), file]),
-        ...changes.deleted.map((file) => [(0, exports.red)("deleted "), file]),
-    ].sort((left, right) => (left[1] < right[1] ? -1 : left[1] > right[1] ? 1 : 0));
-    for (const [mark, file] of rows.slice(0, limit))
-        console.log(`  ${mark}${file}`);
-    if (rows.length > limit)
-        console.log((0, exports.dim)(`  … and ${rows.length - limit} more`));
-}
+const paint_js_1 = require("./paint.js");
+Object.defineProperty(exports, "accent", { enumerable: true, get: function () { return paint_js_1.accent; } });
+Object.defineProperty(exports, "bold", { enumerable: true, get: function () { return paint_js_1.bold; } });
+Object.defineProperty(exports, "dim", { enumerable: true, get: function () { return paint_js_1.dim; } });
+Object.defineProperty(exports, "green", { enumerable: true, get: function () { return paint_js_1.green; } });
+Object.defineProperty(exports, "red", { enumerable: true, get: function () { return paint_js_1.red; } });
+Object.defineProperty(exports, "short", { enumerable: true, get: function () { return paint_js_1.short; } });
+const status_lines_js_1 = require("./status_lines.js");
+Object.defineProperty(exports, "plural", { enumerable: true, get: function () { return status_lines_js_1.plural; } });
+Object.defineProperty(exports, "printChanges", { enumerable: true, get: function () { return status_lines_js_1.printChanges; } });
 /** The status of a local history, printed. */
 async function printLocalStatus(repository) {
     const now = await (0, history_js_1.status)(repository);
-    console.log(`${(0, exports.bold)(node_path_1.default.basename(repository.root))} on ${(0, exports.accent)(now.line)}` +
-        (now.head ? (0, exports.dim)(`  last saved ${(0, exports.short)(now.head.id)}: ${now.head.message.split("\n")[0]}`) : (0, exports.dim)("  nothing saved yet")));
+    console.log(`${(0, paint_js_1.bold)(node_path_1.default.basename(repository.root))} on ${(0, paint_js_1.accent)(now.line)}` +
+        (now.head ? (0, paint_js_1.dim)(`  last saved ${(0, paint_js_1.short)(now.head.id)}: ${now.head.message.split("\n")[0]}`) : (0, paint_js_1.dim)("  nothing saved yet")));
     if (now.merging) {
         const left = now.merging.unresolved.length;
-        console.log(`Merging ${(0, exports.accent)((0, exports.short)(now.merging.theirs))}: ` +
-            (left ? (0, exports.red)(`${(0, exports.plural)(left, "file")} still ${left === 1 ? "has" : "have"} conflict markers`) : (0, exports.green)("no conflict markers left")));
+        console.log(`Merging ${(0, paint_js_1.accent)((0, paint_js_1.short)(now.merging.theirs))}: ` +
+            (left ? (0, paint_js_1.red)(`${(0, status_lines_js_1.plural)(left, "file")} still ${left === 1 ? "has" : "have"} conflict markers`) : (0, paint_js_1.green)("no conflict markers left")));
         for (const conflict of now.merging.conflicts) {
             const how = conflict.kind === "text"
                 ? now.merging.unresolved.includes(conflict.path) ? "markers in it" : "edited"
@@ -56,17 +43,15 @@ async function printLocalStatus(repository) {
                     : conflict.kind === "deleted-here"
                         ? "deleted here, changed there; their copy is in the folder"
                         : "changed here, deleted there; this copy is in the folder";
-            console.log(`  ${(0, exports.red)("conflict")} ${conflict.path}  ${(0, exports.dim)(how)}`);
+            console.log(`  ${(0, paint_js_1.red)("conflict")} ${conflict.path}  ${(0, paint_js_1.dim)(how)}`);
         }
-        console.log((0, exports.dim)(`Finish with cbx save, take a side with cbx merge --mine or --theirs, or cbx merge --cancel.`));
+        console.log((0, paint_js_1.dim)(`Finish with cbx save, take a side with cbx merge --mine or --theirs, or cbx merge --cancel.`));
     }
     const count = (0, history_js_1.changeCount)(now.changes);
     if (!count) {
         console.log("Nothing has changed since the last save.");
         return 0;
     }
-    console.log(`${(0, exports.plural)(count, "file")} changed since the last save:`);
-    printChanges(now.changes);
-    console.log((0, exports.dim)(`cbx diff shows the lines; cbx save -m "…" records them.`));
+    (0, status_lines_js_1.printChangedSummary)(now.changes);
     return 0;
 }

package/dist/cli/src/paint.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.short = exports.accent = exports.green = exports.red = exports.bold = exports.dim = void 0;
+/**
+ * The colours cbx prints in, on their own so the quickest paths (bin.ts)
+ * can print exactly what the full commands print without loading them.
+ */
+const ESC = String.fromCharCode(27);
+const paint = (code) => (value) => `${ESC}[${code}m${value}${ESC}[0m`;
+exports.dim = paint("2");
+exports.bold = paint("1");
+exports.red = paint("31");
+exports.green = paint("32");
+exports.accent = paint("33");
+const short = (id) => id.slice(0, 10);
+exports.short = short;

package/dist/cli/src/status_lines.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.plural = void 0;
+exports.printChanges = printChanges;
+exports.printChangedSummary = printChangedSummary;
+const paint_js_1 = require("./paint.js");
+const plural = (count, one, many = `${one}s`) => `${count.toLocaleString()} ${count === 1 ? one : many}`;
+exports.plural = plural;
+function printChanges(changes, limit = 50) {
+    const rows = [
+        ...changes.added.map((file) => [(0, paint_js_1.green)("added   "), file]),
+        ...changes.modified.map((file) => [(0, paint_js_1.accent)("changed "), file]),
+        ...changes.deleted.map((file) => [(0, paint_js_1.red)("deleted "), file]),
+    ].sort((left, right) => (left[1] < right[1] ? -1 : left[1] > right[1] ? 1 : 0));
+    for (const [mark, file] of rows.slice(0, limit))
+        console.log(`  ${mark}${file}`);
+    if (rows.length > limit)
+        console.log((0, paint_js_1.dim)(`  … and ${rows.length - limit} more`));
+}
+/** Everything after the first line when something changed. */
+function printChangedSummary(changes) {
+    const count = changes.added.length + changes.modified.length + changes.deleted.length;
+    console.log(`${(0, exports.plural)(count, "file")} changed since the last save:`);
+    printChanges(changes);
+    console.log((0, paint_js_1.dim)(`cbx diff shows the lines; cbx save -m "…" records them.`));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@coderook/cli",
-  "version": "0.46.1",
+  "version": "0.46.3",
   "description": "The command line for CodeRook (coderook.com): version control and project hosting for projects of any size. Every save is a compressed snapshot, private or public, never used to train AI.",
   "license": "Apache-2.0",
   "homepage": "https://coderook.com",