@coderook/cli 0.31.13 → 0.32.1

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

@@ -0,0 +1,258 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ObjectStore = exports.PACKED_OBJECT_LIMIT = exports.DIGEST = void 0;
+exports.digestOf = digestOf;
+/**
+ * The object store under `.cbx/objects`: everything a local history holds.
+ *
+ * Every object is named by the SHA-256 of its original bytes and kept as a
+ * chunk frame (see `core/cbx.ts`), so it is compressed when that saves at
+ * least two percent and verified whenever it is read. Pieces of files, the
+ * trees that list them and the saves that name a tree are all objects; an
+ * object never changes once written, which is what makes writing one safe to
+ * repeat and a store safe to copy while nothing is saving.
+ *
+ *   .cbx/objects/ab/cdef…        one object on its own ("loose")
+ *   .cbx/objects/packs/<id>.pack  many small objects, frame after frame
+ *   .cbx/objects/packs/<id>.idx   where each of them starts, as JSON
+ *
+ * Small objects go into packs because a file per object is what made the
+ * first save of twenty thousand small files take thirty-six seconds on
+ * Windows, nearly all of it creating files. A pack is written whole and
+ * renamed into place before its index is, so an index on disk always
+ * describes a finished pack; a pack with no index is an interrupted write
+ * and is never read.
+ */
+const node_crypto_1 = require("node:crypto");
+const promises_1 = require("node:fs/promises");
+const node_path_1 = __importDefault(require("node:path"));
+const cbx_js_1 = require("../core/cbx.js");
+exports.DIGEST = /^[0-9a-f]{64}$/;
+/** Objects at most this big are packed rather than written on their own. */
+exports.PACKED_OBJECT_LIMIT = 256 * 1024;
+/** A pack is written out once it holds this much. */
+const PACK_BYTES = 32 * 1024 * 1024;
+function digestOf(bytes) {
+    return (0, node_crypto_1.createHash)("sha256").update(bytes).digest("hex");
+}
+class ObjectStore {
+    directory;
+    /* Fan-out folders already known to exist, so each is made once, not per object. */
+    made = new Set();
+    /* Every packed object, once the indexes have been read. */
+    packed = null;
+    /* Small objects waiting to be written as one pack. */
+    pending = new Map();
+    /* The batch being written right now, still readable while it is. */
+    writing = new Map();
+    pendingBytes = 0;
+    flushing = null;
+    /*
+      Packs held open while an operation reads from them. Opening a pack for
+      each object made restoring twenty thousand small files take three
+      minutes. Closed by `release`, which every operation calls when it ends,
+      because Windows will not delete a folder holding an open file.
+    */
+    handles = new Map();
+    constructor(directory) {
+        this.directory = directory;
+    }
+    get packDirectory() {
+        return node_path_1.default.join(this.directory, "packs");
+    }
+    where(digest) {
+        if (!exports.DIGEST.test(digest))
+            throw new Error(`Not an object name: ${digest}`);
+        return node_path_1.default.join(this.directory, digest.slice(0, 2), digest.slice(2));
+    }
+    async packs() {
+        if (this.packed)
+            return this.packed;
+        const found = new Map();
+        let names = [];
+        try {
+            names = await (0, promises_1.readdir)(this.packDirectory);
+        }
+        catch {
+            /* No packs yet. */
+        }
+        for (const name of names.filter((one) => one.endsWith(".idx")).sort()) {
+            const pack = node_path_1.default.join(this.packDirectory, name.replace(/\.idx$/, ".pack"));
+            const index = JSON.parse(await (0, promises_1.readFile)(node_path_1.default.join(this.packDirectory, name), "utf8"));
+            for (const [digest, [offset, length]] of Object.entries(index)) {
+                found.set(digest, { pack, offset, length });
+            }
+        }
+        this.packed = found;
+        return found;
+    }
+    async loose(digest) {
+        try {
+            await (0, promises_1.stat)(this.where(digest));
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async has(digest) {
+        if (this.pending.has(digest) || this.writing.has(digest))
+            return true;
+        if ((await this.packs()).has(digest))
+            return true;
+        return this.loose(digest);
+    }
+    /**
+     * Keep `raw`, returning its name.
+     *
+     * A small object is held until there is a pack's worth, then written with
+     * the others; call `flush` before anything else needs to read it from disk.
+     * A large one is written beside its final name and renamed into place, so
+     * an interrupted save never leaves half an object under a real name. An
+     * object already present is not written again: same name, same bytes.
+     */
+    async put(raw, options = {}) {
+        const digest = digestOf(raw);
+        if (await this.has(digest))
+            return digest;
+        const { frame } = (0, cbx_js_1.chunkFrame)(raw);
+        if (!options.loose && raw.length <= exports.PACKED_OBJECT_LIMIT) {
+            this.pending.set(digest, frame);
+            this.pendingBytes += frame.length;
+            if (this.pendingBytes >= PACK_BYTES)
+                await this.flush();
+            return digest;
+        }
+        const target = this.where(digest);
+        const folder = node_path_1.default.dirname(target);
+        if (!this.made.has(folder)) {
+            await (0, promises_1.mkdir)(folder, { recursive: true });
+            this.made.add(folder);
+        }
+        const partial = `${target}.${(0, node_crypto_1.randomBytes)(6).toString("hex")}.partial`;
+        await (0, promises_1.writeFile)(partial, frame);
+        try {
+            await (0, promises_1.rename)(partial, target);
+        }
+        catch (error) {
+            await (0, promises_1.rm)(partial, { force: true });
+            /* Another writer got there first with the same bytes. */
+            if (!(await this.loose(digest)))
+                throw error;
+        }
+        return digest;
+    }
+    /** Write whatever small objects are waiting as one pack. */
+    async flush() {
+        /* One pack at a time; a second caller waits for the first and goes again. */
+        while (this.flushing)
+            await this.flushing;
+        if (!this.pending.size)
+            return;
+        const taken = this.pending;
+        this.pending = new Map();
+        this.pendingBytes = 0;
+        this.writing = taken;
+        this.flushing = this.writePack(taken).finally(() => {
+            this.writing = new Map();
+            this.flushing = null;
+        });
+        await this.flushing;
+    }
+    async writePack(objects) {
+        await (0, promises_1.mkdir)(this.packDirectory, { recursive: true });
+        const index = {};
+        const frames = [];
+        let offset = 0;
+        for (const [digest, frame] of [...objects].sort(([left], [right]) => (left < right ? -1 : 1))) {
+            index[digest] = [offset, frame.length];
+            frames.push(frame);
+            offset += frame.length;
+        }
+        const body = Buffer.concat(frames);
+        const id = digestOf(body);
+        const pack = node_path_1.default.join(this.packDirectory, `${id}.pack`);
+        const idx = node_path_1.default.join(this.packDirectory, `${id}.idx`);
+        await (0, promises_1.writeFile)(`${pack}.partial`, body);
+        await (0, promises_1.rename)(`${pack}.partial`, pack);
+        await (0, promises_1.writeFile)(`${idx}.partial`, JSON.stringify(index));
+        await (0, promises_1.rename)(`${idx}.partial`, idx);
+        const known = await this.packs();
+        for (const [digest, [at, length]] of Object.entries(index)) {
+            known.set(digest, { pack, offset: at, length });
+        }
+    }
+    async get(digest) {
+        const waiting = this.pending.get(digest) ?? this.writing.get(digest);
+        if (waiting)
+            return (0, cbx_js_1.openChunkFrame)(waiting, digest);
+        const located = (await this.packs()).get(digest);
+        if (located) {
+            let opening = this.handles.get(located.pack);
+            if (!opening) {
+                opening = (0, promises_1.open)(located.pack, "r");
+                this.handles.set(located.pack, opening);
+            }
+            const handle = await opening;
+            const frame = Buffer.alloc(located.length);
+            const { bytesRead } = await handle.read(frame, 0, located.length, located.offset);
+            if (bytesRead !== located.length) {
+                throw new Error(`Object ${digest.slice(0, 12)} runs past the end of its pack`);
+            }
+            return (0, cbx_js_1.openChunkFrame)(frame, digest);
+        }
+        let frame;
+        try {
+            frame = await (0, promises_1.readFile)(this.where(digest));
+        }
+        catch {
+            throw new Error(`The history is missing object ${digest.slice(0, 12)}`);
+        }
+        return (0, cbx_js_1.openChunkFrame)(frame, digest);
+    }
+    /** Close any packs held open for reading. Safe to call at any time. */
+    async release() {
+        const open = [...this.handles.values()];
+        this.handles.clear();
+        for (const opening of open) {
+            try {
+                await (await opening).close();
+            }
+            catch {
+                /* Never opened, or already closed. */
+            }
+        }
+    }
+    /** Stored on its own, so a save or tree is one file a person can find. */
+    async putJson(value) {
+        return this.put(Buffer.from(JSON.stringify(value), "utf8"), { loose: true });
+    }
+    async getJson(digest) {
+        return JSON.parse((await this.get(digest)).toString("utf8"));
+    }
+    /** Every object whose name starts with `prefix` (at least four characters). */
+    async matching(prefix) {
+        if (!/^[0-9a-f]{4,64}$/.test(prefix))
+            return [];
+        const found = new Set();
+        try {
+            const rest = prefix.slice(2);
+            for (const name of await (0, promises_1.readdir)(node_path_1.default.join(this.directory, prefix.slice(0, 2)))) {
+                if (name.length === 62 && name.startsWith(rest))
+                    found.add(prefix.slice(0, 2) + name);
+            }
+        }
+        catch {
+            /* No loose objects under that prefix. */
+        }
+        for (const digest of (await this.packs()).keys()) {
+            if (digest.startsWith(prefix))
+                found.add(digest);
+        }
+        return [...found];
+    }
+}
+exports.ObjectStore = ObjectStore;

package/dist/{desktop-app → cbx}/src/shared/safe_path.js

@@ -4,6 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isGitDirectoryName = isGitDirectoryName;
+exports.isCbxDirectoryName = isCbxDirectoryName;
 exports.whyUnsafe = whyUnsafe;
 exports.safeParts = safeParts;
 exports.inside = inside;
@@ -38,6 +39,15 @@ function isGitDirectoryName(part) {
     const name = part.split(":")[0].replace(/[. ]+$/, "").toLowerCase();
     return name === ".git" || /^git~\d+$/.test(name);
 }
+/**
+ * A name CBX keeps its local history under, compared the way git's is.
+ *
+ * A version holding `.cbx/lines/main` would otherwise move somebody's line to
+ * a save of the version's choosing the moment it was fetched.
+ */
+function isCbxDirectoryName(part) {
+    return part.split(":")[0].replace(/[. ]+$/, "").toLowerCase() === ".cbx";
+}
 /** Why this path must not be written, or null when it may. */
 function whyUnsafe(relative) {
     if (!relative)
@@ -52,6 +62,8 @@ function whyUnsafe(relative) {
             return "it climbs out of the folder";
         if (isGitDirectoryName(part))
             return "it writes into git's own directory";
+        if (isCbxDirectoryName(part))
+            return "it writes into CBX's own history";
         /* A stream or a drive-relative name on Windows; refused by the service too. */
         if (process.platform === "win32" && part.includes(":")) {
             return "it names a Windows data stream";

package/dist/cli/src/api.js

@@ -58,7 +58,7 @@ exports.addWebhook = addWebhook;
 exports.removeWebhook = removeWebhook;
 exports.collisionCheck = collisionCheck;
 /** The small part of the API the command-line tool needs directly. */
-const identify_js_1 = require("../../desktop-app/src/main/identify.js");
+const identify_js_1 = require("../../cbx/src/core/identify.js");
 const config_js_1 = require("./config.js");
 /**
  * How long one request may go unanswered before it is treated as lost.

package/dist/cli/src/cli.js

@@ -30,24 +30,25 @@ const attach_command_js_1 = require("./attach_command.js");
 const pages_command_js_1 = require("./pages_command.js");
 const project_commands_js_1 = require("./project_commands.js");
 const track_commands_js_1 = require("./track_commands.js");
-const tracks_js_1 = require("../../desktop-app/src/main/tracks.js");
+const tracks_js_1 = require("../../cbx/src/core/tracks.js");
 const transfer_command_js_1 = require("./transfer_command.js");
 const mcp_js_1 = require("./mcp.js");
 const skill_command_js_1 = require("./skill_command.js");
 const licence_commands_js_1 = require("./licence_commands.js");
 const service_commands_js_1 = require("./service_commands.js");
-const worktree_js_1 = require("../../desktop-app/src/main/worktree.js");
-const rules_js_1 = require("../../desktop-app/src/main/rules.js");
-const upload_js_1 = require("../../desktop-app/src/main/upload.js");
-const download_js_1 = require("../../desktop-app/src/main/download.js");
-const safe_path_js_1 = require("../../desktop-app/src/shared/safe_path.js");
-const faults_js_1 = require("../../desktop-app/src/main/faults.js");
+const worktree_js_1 = require("../../cbx/src/core/worktree.js");
+const rules_js_1 = require("../../cbx/src/core/rules.js");
+const upload_js_1 = require("../../cbx/src/core/upload.js");
+const download_js_1 = require("../../cbx/src/core/download.js");
+const safe_path_js_1 = require("../../cbx/src/shared/safe_path.js");
+const faults_js_1 = require("../../cbx/src/core/faults.js");
 const version_commands_js_1 = require("./version_commands.js");
-const identify_js_1 = require("../../desktop-app/src/main/identify.js");
+const identify_js_1 = require("../../cbx/src/core/identify.js");
 const diff_command_js_1 = require("./diff_command.js");
-const profile_js_1 = require("../../desktop-app/src/main/profile.js");
-const detect_js_1 = require("../../desktop-app/src/main/detect.js");
-const cbx_js_1 = require("../../desktop-app/src/main/cbx.js");
+const local_commands_js_1 = require("./local_commands.js");
+const profile_js_1 = require("../../cbx/src/core/profile.js");
+const detect_js_1 = require("../../cbx/src/core/detect.js");
+const cbx_js_1 = require("../../cbx/src/core/cbx.js");
 const api_js_2 = require("./api.js");
 const import_command_js_1 = require("./import_command.js");
 const runner_js_1 = require("./runner.js");
@@ -154,7 +155,12 @@ function parse(argv, spec) {
           their options rely on it, and narrowing that here would trade one
           quiet misreading for another.
         */
-        const wants = takesValue.size ? takesValue.has(name) : true;
+        /*
+          A command that declares any options has declared them all, including
+          when none of them takes a value. Keying this on the value-taking ones
+          alone let `cbx switch -c spike` read "spike" as the value of `-c`.
+        */
+        const wants = spec?.options?.length ? takesValue.has(name) : true;
         if (wants && next !== undefined && !next.startsWith("-")) {
             flags.set(name, next);
             at += 1;
@@ -1961,12 +1967,14 @@ const SPECS = [
         summary: "what is here that is not saved yet",
         usage: "status [folder]",
         detail: "Compares the folder against the last version you sent and lists what\n" +
-            "changed. Says nothing about other people's work — use `merges` for that.",
-        run: commandStatus,
+            "changed. Says nothing about other people's work — use `merges` for that.\n\n" +
+            "In a folder with a history of its own (see `cbx init`), compares\n" +
+            "against the last local save instead.",
+        run: (0, local_commands_js_1.localFirst)(local_commands_js_1.localStatus, commandStatus, (parsed) => folderFor(parsed)),
     },
     {
         name: "submit",
-        aliases: ["publish", "push"],
+        aliases: ["publish"],
         group: "Working with a folder",
         summary: "send the changes as a new save",
         usage: 'submit [folder] -m "…"',
@@ -2017,7 +2025,9 @@ const SPECS = [
             "compares two saved versions — which the service answers from its own\n" +
             "stored trees, so an untouched corner of a large project costs nothing.\n\n" +
             "A version can be given as a number, as v12, or by the name it was\n" +
-            "released under.",
+            "released under.\n\n" +
+            "In a folder with a history of its own (see `cbx init`), the same\n" +
+            "positions name local saves: a line, a line~N, or the start of an id.",
         options: [
             { flags: "--name-only", description: "list the files and not their lines" },
             { flags: "--path <text>", description: "only paths containing this" },
@@ -2027,8 +2037,94 @@ const SPECS = [
             },
             { flags: "--project <name>", description: "which project" },
         ],
-        examples: ["cbx diff", "cbx diff 12", "cbx diff 11 12 --name-only"],
-        run: diff_command_js_1.commandDiff,
+        examples: ["cbx diff", "cbx diff 12", "cbx diff 11 12 --name-only", "cbx diff main~1 main"],
+        run: (0, local_commands_js_1.localFirst)(local_commands_js_1.localDiff, diff_command_js_1.commandDiff),
+    },
+    {
+        name: "init",
+        group: "History on this machine",
+        summary: "start a history in this folder, kept on this machine",
+        usage: "init [folder]",
+        detail: "Makes a .cbx/ folder holding the project's history, so you can save,\n" +
+            "compare and go back with no connection at all. Nothing in it is sent\n" +
+            "anywhere by itself.\n\n" +
+            "Once a folder has one, `status`, `diff`, `log` and `switch` answer from\n" +
+            "it. `submit` still sends the folder to CodeRook as it always has.",
+        options: [{ flags: "--line <name>", description: "what to call the first line (default main)" }],
+        examples: ["cbx init", "cbx init my-game --line dev"],
+        run: local_commands_js_1.commandInit,
+    },
+    {
+        name: "save",
+        group: "History on this machine",
+        summary: "record the folder as it is now, on this machine",
+        usage: 'save -m "…"',
+        detail: "Records every file the ignore rules let through, on the line the\n" +
+            "folder is on. Only files that changed are read again, and a large file\n" +
+            "is split so an edit stores the pieces around it rather than all of it.\n\n" +
+            "A save identical to the last one is not made.",
+        options: [
+            { flags: "-m, --message <text>", description: "what changed" },
+            { flags: "--author <name>", description: "who to record, instead of the configured name" },
+            { flags: "-f, --force", description: "finish a merge even though conflict markers remain" },
+        ],
+        examples: ['cbx save -m "Tune the jump height"'],
+        run: local_commands_js_1.commandSave,
+    },
+    {
+        name: "log",
+        group: "History on this machine",
+        summary: "the saves on this line, newest first",
+        usage: "log [from]",
+        detail: "In a folder with a history of its own, lists its saves along the line,\n" +
+            "newest first. Start somewhere else by naming a line or a save.\n\n" +
+            "Anywhere else, lists what has been saved to the project on CodeRook,\n" +
+            "as `cbx versions` does.",
+        options: [
+            { flags: "--limit <n>", description: "how many to show (default 20)" },
+            { flags: "--versions", description: "on CodeRook: only the ones that were named" },
+            { flags: "--commits", description: "on CodeRook: only the ones that were not" },
+            { flags: "--notes", description: "on CodeRook: print what each one says about itself" },
+        ],
+        examples: ["cbx log", "cbx log feature --limit 5"],
+        run: (0, local_commands_js_1.localFirst)(local_commands_js_1.localLog, project_commands_js_1.commandVersions),
+    },
+    {
+        name: "restore",
+        group: "History on this machine",
+        summary: "put files back the way a save had them",
+        usage: "restore [paths…] [--from <save>]",
+        detail: "With no paths, makes the whole folder match the save; with paths,\n" +
+            "only those files and folders. The default is the last save, which\n" +
+            "throws away what you changed since.\n\n" +
+            "Unsaved changes to a file it would overwrite stop it, and it lists\n" +
+            "them. Add --force to discard them. Files the history has never held\n" +
+            "are left alone either way, and your line does not move.",
+        options: [
+            { flags: "--from <save>", description: "a line, line~N, or the start of a save id" },
+            { flags: "-f, --force", description: "overwrite unsaved changes" },
+        ],
+        examples: ["cbx restore src/player.ts --force", "cbx restore --from main~3"],
+        run: local_commands_js_1.commandRestore,
+    },
+    {
+        name: "switch",
+        group: "History on this machine",
+        summary: "move this folder to another line of work",
+        usage: "switch [line]",
+        detail: "In a folder with a history of its own, rewrites only the files the two\n" +
+            "lines disagree about; unsaved edits elsewhere come along. Unsaved\n" +
+            "edits to a file it would change stop it. -c starts a new line from the\n" +
+            "current save without changing any files. With no line, lists them.\n\n" +
+            "Anywhere else, changes the CodeRook line this folder saves to, as\n" +
+            "`cbx track` does.",
+        options: [
+            { flags: "-c, --create", description: "start a new line here" },
+            { flags: "-f, --force", description: "discard unsaved changes that are in the way" },
+            { flags: "-n, --new", description: "on CodeRook: start this line from where the project is now" },
+        ],
+        examples: ["cbx switch", "cbx switch -c spike", "cbx switch main"],
+        run: (0, local_commands_js_1.localFirst)(local_commands_js_1.localSwitch, track_commands_js_1.commandTrack),
     },
     {
         name: "unlink",
@@ -2120,7 +2216,7 @@ const SPECS = [
           different lines, which is most of the point of having them.
         */
         name: "track",
-        aliases: ["switch", "checkout"],
+        aliases: ["checkout"],
         group: "Working with a folder",
         summary: "show or change the line this folder saves to",
         usage: "track [name]",
@@ -2154,7 +2250,6 @@ const SPECS = [
     },
     {
         name: "get",
-        aliases: ["pull"],
         group: "Working with a folder",
         summary: "bring this folder up to date",
         usage: "get [folder]",
@@ -2251,7 +2346,6 @@ const SPECS = [
     },
     {
         name: "versions",
-        aliases: ["log"],
         group: "Your projects",
         summary: "what has been saved to a project",
         usage: "versions [project]",
@@ -2798,9 +2892,17 @@ const SPECS = [
     {
         name: "merge",
         group: "When somebody saved first",
-        summary: "look at one, and decide",
-        usage: "merge <ref>",
+        summary: "merge a line here, or decide one waiting on CodeRook",
+        usage: "merge <line | ref>",
+        detail: "In a folder with a history of its own, merges a line or a save into\n" +
+            "this one. What only one side changed is taken; a text file both\n" +
+            "changed is merged line by line; only what is left is a conflict,\n" +
+            "marked in the file. Fix them and save, or take a side whole with\n" +
+            "--mine or --theirs, or call it off with --cancel.\n\n" +
+            "Anywhere else, decides a merge waiting on CodeRook.",
         options: [
+            { flags: "-m, --message <text>", description: "what the merge save says" },
+            { flags: "--abort", description: "the same as --cancel" },
             { flags: "--mine", description: "keep your side" },
             { flags: "--theirs", description: "keep theirs" },
             { flags: "--both", description: "keep both" },
@@ -2809,7 +2911,7 @@ const SPECS = [
             { flags: "--cancel", description: "call the merge off; your upload stays stored" },
             { flags: "--ask <usernames>", description: "ask people to review it, comma separated" },
         ],
-        run: commandMerge,
+        run: (0, local_commands_js_1.localFirst)(local_commands_js_1.localMerge, commandMerge),
     },
     {
         name: "bundle",
@@ -2922,6 +3024,46 @@ const SPECS = [
         run: () => commandDoctor(),
     },
 ];
+/*
+  `push` and `pull` mean the local history in a folder that has one, and
+  `submit` and `get` everywhere else, which is what they always meant. Built
+  from those two rows so every option they take still parses when the name
+  falls through to them.
+*/
+function localTwin(name, original, local, row, extra) {
+    const spec = SPECS.find((one) => one.name === original);
+    const taken = new Set(extra.map((one) => one.flags));
+    return {
+        name,
+        group: "History on this machine",
+        ...row,
+        options: [...extra, ...(spec.options ?? []).filter((one) => !taken.has(one.flags))],
+        run: (0, local_commands_js_1.localFirst)(local, spec.run),
+    };
+}
+SPECS.push(localTwin("push", "submit", local_commands_js_1.localPush, {
+    summary: "send this line's saves to CodeRook",
+    usage: "push",
+    detail: "In a folder with a history of its own, sends each save on this line that\n" +
+        "CodeRook does not have yet, oldest first, as a save of its own. Only\n" +
+        "what changed in each is sent. The first push creates the project,\n" +
+        "private, unless the folder is already linked to one.\n\n" +
+        "If CodeRook's line has saves this history does not, nothing is sent:\n" +
+        "run `cbx pull` first.\n\n" +
+        "Anywhere else, this is `cbx submit`.",
+    examples: ["cbx push", "cbx push --allow-secrets"],
+}, [{ flags: "-y, --yes", description: "go ahead past the checks that ask first" }]), localTwin("pull", "get", local_commands_js_1.localPull, {
+    summary: "bring CodeRook's saves on this line into this history",
+    usage: "pull [project]",
+    detail: "In a folder with a history of its own, fetches the saves CodeRook has on\n" +
+        "this line and this history does not, and moves the folder to the newest.\n" +
+        "Only files that differ are fetched and rewritten; an unsaved edit to\n" +
+        "one of them stops it. Name a project to pull from it the first time.\n\n" +
+        "If this history has saves CodeRook does not, CodeRook's are fetched\n" +
+        "but the folder stays put: merging a local history is not built yet.\n\n" +
+        "Anywhere else, this is `cbx get`.",
+    examples: ["cbx pull", "cbx pull my-project"],
+}, [{ flags: "-f, --force", description: "discard unsaved changes that are in the way" }]));
 const REGISTRY = (0, registry_js_1.buildRegistry)(SPECS);
 async function main(argv) {
     const [name, ...rest] = argv;

package/dist/cli/src/diff_command.js

@@ -27,8 +27,8 @@ const node_process_1 = __importDefault(require("node:process"));
 const api_js_1 = require("./api.js");
 const config_js_1 = require("./config.js");
 const project_commands_js_1 = require("./project_commands.js");
-const merge_diff_js_1 = require("../../desktop-app/src/shared/merge_diff.js");
-const worktree_js_1 = require("../../desktop-app/src/main/worktree.js");
+const merge_diff_js_1 = require("../../cbx/src/shared/merge_diff.js");
+const worktree_js_1 = require("../../cbx/src/core/worktree.js");
 /*
   Built rather than typed, so the escape character never sits literally in the
   source. The other command files spell theirs out; this reads the same on a

package/dist/cli/src/git_remote.js

@@ -109,15 +109,15 @@ exports.main = main;
  * where the original branched.
  */
 const node_child_process_1 = require("node:child_process");
-const safe_path_js_1 = require("../../desktop-app/src/shared/safe_path.js");
+const safe_path_js_1 = require("../../cbx/src/shared/safe_path.js");
 const promises_1 = require("node:fs/promises");
 const node_os_1 = __importDefault(require("node:os"));
 const node_path_1 = __importDefault(require("node:path"));
 const node_process_1 = __importDefault(require("node:process"));
-const upload_js_1 = require("../../desktop-app/src/main/upload.js");
+const upload_js_1 = require("../../cbx/src/core/upload.js");
 const stored_zip_js_1 = require("./stored_zip.js");
-const tracks_js_1 = require("../../desktop-app/src/main/tracks.js");
-const identify_js_1 = require("../../desktop-app/src/main/identify.js");
+const tracks_js_1 = require("../../cbx/src/core/tracks.js");
+const identify_js_1 = require("../../cbx/src/core/identify.js");
 const config_js_1 = require("./config.js");
 const version_js_1 = require("./version.js");
 const publish_js_1 = require("./publish.js");
@@ -673,7 +673,7 @@ depth = null) {
             ? ` (${chosen.length - fresh.length} already here)`
             : "") +
         ".");
-    const { Downloader } = await Promise.resolve().then(() => __importStar(require("../../desktop-app/src/main/download.js")));
+    const { Downloader } = await Promise.resolve().then(() => __importStar(require("../../cbx/src/core/download.js")));
     const downloader = new Downloader(config_js_1.credentials);
     const scratch = await (0, promises_1.mkdtemp)(node_path_1.default.join(node_os_1.default.tmpdir(), "coderook-fetch-"));
     try {
@@ -1262,7 +1262,7 @@ async function doPush(requests, url) {
                             throw error;
                     }
                 }
-                const { Downloader } = await Promise.resolve().then(() => __importStar(require("../../desktop-app/src/main/download.js")));
+                const { Downloader } = await Promise.resolve().then(() => __importStar(require("../../cbx/src/core/download.js")));
                 const held = await new Downloader(config_js_1.credentials).files(repositoryId, baseVersionId);
                 manifest = Object.fromEntries(held.map((file) => [file.path, file.sha256]));
                 local = { ...manifest };

package/dist/cli/src/licence_commands.js

@@ -21,10 +21,10 @@ exports.commandLicence = commandLicence;
 exports.commandIgnoreTemplate = commandIgnoreTemplate;
 const promises_1 = require("node:fs/promises");
 const node_path_1 = __importDefault(require("node:path"));
-const licences_js_1 = require("../../desktop-app/src/main/licences.js");
+const licences_js_1 = require("../../cbx/src/core/licences.js");
 Object.defineProperty(exports, "licenceNewProject", { enumerable: true, get: function () { return licences_js_1.licenceNewProject; } });
-const ignore_templates_js_1 = require("../../desktop-app/src/main/ignore_templates.js");
-const worktree_js_1 = require("../../desktop-app/src/main/worktree.js");
+const ignore_templates_js_1 = require("../../cbx/src/core/ignore_templates.js");
+const worktree_js_1 = require("../../cbx/src/core/worktree.js");
 const api_js_1 = require("./api.js");
 const dim = (value) => `${value}`;
 const bold = (value) => `${value}`;