@coderook/cli 0.23.0 → 0.25.0

package/dist/cli/src/git_remote_bin.js

@@ -0,0 +1,22 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/*
+  The executable half of `git-remote-coderook`.
+
+  Split from the module that does the work so that module can be imported by a
+  test without starting the protocol loop. Merging the two costs nothing to
+  write and means every test of a pure function first has to stop a process
+  from reading stdin and answering git.
+*/
+const node_process_1 = __importDefault(require("node:process"));
+const git_remote_js_1 = require("./git_remote.js");
+(0, git_remote_js_1.main)(node_process_1.default.argv.slice(2))
+    .then((code) => node_process_1.default.exit(code))
+    .catch((error) => {
+    node_process_1.default.stderr.write(`git-remote-coderook: ${error instanceof Error ? error.message : String(error)}\n`);
+    node_process_1.default.exit(1);
+});

package/dist/cli/src/help.js

@@ -1,6 +1,6 @@
 "use strict";
 /**
- * What `coderook help` prints.
+ * What `cbx help` prints.
  *
  * Generated from the registry rather than written out, so a command that
  * exists is listed and a command that is listed exists. The previous usage
@@ -30,7 +30,7 @@ function renderHelp(registry, version) {
     const listed = registry.specs.filter((spec) => !spec.deprecatedBy);
     const column = Math.min(nameColumn(listed), 34);
     const lines = [
-        `${bold("coderook")} ${dim(version)} — CodeRook from the command line`,
+        `${bold("cbx")} ${dim(version)} — the CodeBox engine, for CodeRook`,
         "",
     ];
     for (const group of registry_js_1.GROUP_ORDER) {
@@ -43,18 +43,18 @@ function renderHelp(registry, version) {
         }
         lines.push("");
     }
-    lines.push(dim("coderook help <command>   what one command does, in full"), dim("CODEROOK_TOKEN is used when set, so automated runs need nothing on disk."), dim("CODEROOK_API_URL points at another service."));
+    lines.push(dim("cbx help <command>   what one command does, in full"), dim("CODEROOK_TOKEN is used when set, so automated runs need nothing on disk."), dim("CODEROOK_API_URL points at another service."));
     return lines.join("\n");
 }
 function renderCommandHelp(spec) {
     const lines = [
-        `${bold("coderook " + spec.name)} — ${spec.summary}`,
+        `${bold("cbx " + spec.name)} — ${spec.summary}`,
         "",
         bold("Usage"),
-        `  coderook ${spec.usage}`,
+        `  cbx ${spec.usage}`,
     ];
     if (spec.aliases?.length) {
-        lines.push("", bold("Also"), `  ${spec.aliases.map((alias) => `coderook ${alias}`).join("  ")}`);
+        lines.push("", bold("Also"), `  ${spec.aliases.map((alias) => `cbx ${alias}`).join("  ")}`);
     }
     if (spec.detail) {
         lines.push("", spec.detail.trim());
@@ -82,7 +82,7 @@ function renderCommandHelp(spec) {
 function renderUnknown(typed, suggestion) {
     const lines = [`Unknown command: ${typed}`];
     if (suggestion)
-        lines.push(`Did you mean ${accent("coderook " + suggestion)}?`);
-    lines.push(dim("Run coderook help to see everything."));
+        lines.push(`Did you mean ${accent("cbx " + suggestion)}?`);
+    lines.push(dim("Run cbx help to see everything."));
     return lines.join("\n");
 }

package/dist/cli/src/licence_commands.js

@@ -73,7 +73,7 @@ async function commandLicence(parsed) {
             console.log(`     ${dim(licence.summary)}`);
         }
         console.log("");
-        console.log(`Add one with ${accent("coderook licence MIT")}. ` +
+        console.log(`Add one with ${accent("cbx licence MIT")}. ` +
             dim(`Nothing is written until you name one.`));
         return 0;
     }
@@ -98,7 +98,7 @@ async function commandLicence(parsed) {
     const licence = (0, licences_js_1.licenceById)(wanted);
     if (!licence) {
         console.error(red(`No licence called ${wanted}.`));
-        console.error(`Run ${accent("coderook licence")} to see the list.`);
+        console.error(`Run ${accent("cbx licence")} to see the list.`);
         return 1;
     }
     /*
@@ -162,14 +162,14 @@ async function commandIgnoreTemplate(parsed) {
             console.log("  " + names.slice(at, at + perRow).map((name) => name.padEnd(width)).join(""));
         }
         console.log("");
-        console.log(`Add one with ${accent("coderook ignore --template Python")}. ` +
+        console.log(`Add one with ${accent("cbx ignore --template Python")}. ` +
             dim("Several is normal — a language, an editor, an operating system."));
         return 0;
     }
     const template = ignore_templates_js_1.IGNORE_TEMPLATES[wanted.toLowerCase()];
     if (!template) {
         console.error(red(`No rules called ${wanted}.`));
-        console.error(`Run ${accent("coderook ignore --template list")} to see what there is.`);
+        console.error(`Run ${accent("cbx ignore --template list")} to see what there is.`);
         return 1;
     }
     const rules = await (0, worktree_js_1.readRules)(folder);
@@ -185,7 +185,7 @@ async function commandIgnoreTemplate(parsed) {
     console.log(green(`Added ${template.name} — ${lines.length} rules.`));
     console.log(dim(`  ${node_path_1.default.join(folder, ".gitignore")}`));
     console.log("");
-    console.log(dim(`See what it leaves behind with `) + accent("coderook status"));
+    console.log(dim(`See what it leaves behind with `) + accent("cbx status"));
     return 0;
 }
 function flagValue(parsed, name) {

package/dist/cli/src/mcp.js

@@ -196,7 +196,7 @@ const TOOLS = [
                 throw new Error(`No file "${wanted}" in v${version.sequence}.`);
             if (file.sourceSize > READ_LIMIT) {
                 return (`${wanted} is ${bytes(file.sourceSize)}, larger than this tool will ` +
-                    `paste into a conversation. Fetch the project with \`coderook get\` ` +
+                    `paste into a conversation. Fetch the project with \`cbx get\` ` +
                     `and read it from disk.`);
             }
             /*

package/dist/cli/src/publish.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uploadRequestFor = uploadRequestFor;
+exports.classifyPublishFailure = classifyPublishFailure;
+/** Turn what a caller has into what the uploader expects. */
+function uploadRequestFor(input) {
+    return {
+        localPath: input.localPath,
+        // Both lists. See the note at the top of this file.
+        include: [...input.changed, ...input.deleted],
+        deletions: input.deleted,
+        message: input.message,
+        projectName: input.projectName,
+        repositoryId: input.repositoryId,
+        baseVersionId: input.baseVersionId,
+        ...(input.track ? { track: input.track } : {}),
+        ...(input.allowIgnored ? { allowIgnored: true } : {}),
+        ...(input.acknowledged ? { acknowledged: true } : {}),
+        ...(input.acknowledgedNoLicence ? { acknowledgedNoLicence: true } : {}),
+        ...(input.baseVersionId
+            ? { expectedHeadVersionId: input.baseVersionId }
+            : {}),
+        ...(input.known ? { known: input.known } : {}),
+    };
+}
+function classifyPublishFailure(error) {
+    const code = error?.code;
+    const message = error instanceof Error ? error.message : String(error);
+    if (code === "merge_required" || code === "track_moved") {
+        return { kind: "conflict", message };
+    }
+    if (!code &&
+        /fetch failed|ECONNRESET|socket hang up|network|ETIMEDOUT/i.test(message)) {
+        return { kind: "interrupted", message };
+    }
+    return null;
+}

package/dist/cli/src/registry.js

@@ -7,7 +7,7 @@
  * command gets added and the text does not mention it, or an option is renamed
  * and the text still lists the old one. Nobody notices, because nothing checks.
  *
- * Here the description is part of the command. `coderook help` is generated
+ * Here the description is part of the command. `cbx help` is generated
  * from the same rows that decide what runs, so the two cannot disagree — and a
  * command added without a summary is a type error rather than an omission.
  */

package/dist/cli/src/runner.js

@@ -45,7 +45,7 @@ const FLUSH_MS = 2_000;
 async function call(route, options = {}) {
     const token = await (0, config_js_1.loadToken)();
     if (!token)
-        throw new Error("Not signed in. Run: coderook sign-in");
+        throw new Error("Not signed in. Run: cbx sign-in");
     const response = await fetch(`${(0, config_js_1.apiOrigin)()}${route}`, {
         method: options.method ?? "GET",
         headers: {
@@ -127,7 +127,7 @@ class LogShipper {
  *
  * Running somebody's command on your machine is the deal a runner makes, and
  * it is stated at every startup. Handing them the token that machine signs in
- * with is not: `coderook runner` reads CODEROOK_TOKEN from the environment so
+ * with is not: `cbx runner` reads CODEROOK_TOKEN from the environment so
  * automated runs can supply it, and every child process inherited it. A
  * workflow set to `env` by anyone with write access printed it straight into
  * the run log, which read access is enough to see — so a collaborator could

package/dist/cli/src/service_commands.js

@@ -12,6 +12,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.commandIssues = commandIssues;
+exports.commandRelease = commandRelease;
 exports.commandReleases = commandReleases;
 exports.commandCollaborators = commandCollaborators;
 exports.commandWatch = commandWatch;
@@ -72,6 +73,55 @@ async function commandIssues(parsed) {
     return 0;
 }
 /** Published releases, newest first. */
+/**
+ * Name a version, which is what a release is.
+ *
+ * The service has had `markRelease` since releases existed, and nothing on
+ * this side could reach it — a project could be given a release by the
+ * website and by nothing else. That gap is why `git push --tags` needs this:
+ * a git tag is a name for a version, so it has to call the same thing a person
+ * calls, not a path of its own. A capability git can reach and the CLI cannot
+ * would be a feature that exists twice and agrees by luck.
+ */
+async function commandRelease(parsed) {
+    const name = parsed.positional[0];
+    if (!name) {
+        console.error(red("Name the release: cbx release v1.0"));
+        return 1;
+    }
+    const project = await (0, project_commands_js_1.resolveProject)(parsed.positional[1]);
+    if (!project)
+        return 1;
+    const all = await (0, api_js_1.versions)(project.id);
+    if (!all.length) {
+        console.error(red("This project has no versions to release."));
+        return 1;
+    }
+    /*
+      The newest version unless one is named. A release usually means "what I
+      have just finished", and asking for the number every time would make the
+      common case the awkward one.
+    */
+    const wanted = parsed.flags.get("version");
+    const target = typeof wanted === "string"
+        ? all.find((version) => String(version.sequence) === wanted.replace(/^v/i, ""))
+        : all[0];
+    if (!target) {
+        console.error(red(`This project has no version ${String(wanted)}.`));
+        return 1;
+    }
+    const notes = parsed.flags.get("notes");
+    try {
+        await (0, api_js_1.markRelease)(project.id, target.id, name, typeof notes === "string" ? notes : null);
+    }
+    catch (error) {
+        console.error(red(error instanceof Error ? error.message : String(error)));
+        return 1;
+    }
+    console.log(`${green("Released")} ${bold(name)} ${dim("at")} v${target.sequence}` +
+        `${dim(" — ")}${target.message.split("\n")[0].slice(0, 48)}`);
+    return 0;
+}
 async function commandReleases(parsed) {
     const project = await (0, project_commands_js_1.resolveProject)(parsed.positional[0]);
     if (!project)
@@ -243,7 +293,7 @@ async function commandRuns(parsed) {
             console.log(`    ${dim(aside.join(" · "))}`);
     }
     console.log("");
-    console.log(dim("  Read one with: coderook logs <number>"));
+    console.log(dim("  Read one with: cbx logs <number>"));
     return 0;
 }
 /**
@@ -255,7 +305,7 @@ async function commandRuns(parsed) {
 async function commandLogs(parsed) {
     const asked = parsed.positional[0];
     if (!asked) {
-        console.error(red("Which run? Try: coderook logs 12"));
+        console.error(red("Which run? Try: cbx logs 12"));
         return 1;
     }
     const number = Number(asked.replace(/^#/, ""));
@@ -314,7 +364,7 @@ async function commandTokens(parsed) {
         console.log(`  ${token.name.padEnd(26)} ${used.padEnd(16)} ${dim(token.id)}`);
     }
     console.log("");
-    console.log(dim("  Revoke one with: coderook tokens --revoke <id>"));
+    console.log(dim("  Revoke one with: cbx tokens --revoke <id>"));
     return 0;
 }
 /**

package/dist/cli/src/skill_command.js

@@ -9,7 +9,7 @@
  *
  * A skill is a file in a folder. The command line is already installed and
  * already knows where that folder is, so it writes it: no marketplace, no
- * clone, no second account. `coderook skill` and the assistant knows what
+ * clone, no second account. `cbx skill` and the assistant knows what
  * CodeRook is and how to drive it from then on, in every project.
  *
  * The skill teaches it the command line rather than the MCP server. Both work,
@@ -106,8 +106,8 @@ async function commandSkill(parsed) {
     console.log(dim("or run it by name — ") + accent("/coderook"));
     console.log("");
     console.log(dim("Signed in? ") +
-        bold("coderook whoami") +
+        bold("cbx whoami") +
         dim("  ·  if not: ") +
-        bold("coderook sign-in"));
+        bold("cbx sign-in"));
     return 0;
 }

package/dist/cli/src/track_commands.js

@@ -88,7 +88,7 @@ async function commandTracks(parsed) {
         console.log(bold("Waiting on a decision"));
         for (const track of merges)
             console.log(`  ${describe(track, current)}`);
-        console.log(dim("  Finish one with ") + "coderook merge");
+        console.log(dim("  Finish one with ") + "cbx merge");
     }
     console.log("");
     console.log(dim("This folder saves to ") + accent(current));
@@ -100,20 +100,20 @@ async function commandTracks(parsed) {
  * Switching is a statement about where the next save goes and nothing else:
  * no files move and nothing is fetched, which is why it is instant and why
  * it is safe to change your mind. Getting the other line's files is
- * `coderook get`, deliberately a separate act.
+ * `cbx get`, deliberately a separate act.
  */
 async function commandTrack(parsed) {
     const folder = node_process_1.default.cwd();
     const link = await (0, config_js_1.readLink)(folder);
     if (!link) {
-        console.error(red("This folder is not linked to a project. Run ") + "coderook get" + red(" first."));
+        console.error(red("This folder is not linked to a project. Run ") + "cbx get" + red(" first."));
         return 1;
     }
     const wanted = parsed.positional[0];
     const current = link.track?.trim() || exports.DEFAULT_TRACK;
     if (!wanted) {
         console.log(accent(current));
-        console.log(dim("Switch with ") + "coderook track <name>");
+        console.log(dim("Switch with ") + "cbx track <name>");
         return 0;
     }
     const starting = parsed.flags.has("new") || parsed.flags.has("n");
@@ -130,12 +130,12 @@ async function commandTrack(parsed) {
           work somewhere nobody will look for it.
         */
         console.error(red(`No line called "${wanted}" on this project.`));
-        console.error(dim("Start one with ") + `coderook track ${wanted} --new`);
+        console.error(dim("Start one with ") + `cbx track ${wanted} --new`);
         return 1;
     }
     if (existing?.kind === "merge") {
         console.error(red(`"${wanted}" is a merge waiting on a decision, not a line to save onto.`));
-        console.error(dim("Finish it with ") + "coderook merge");
+        console.error(dim("Finish it with ") + "cbx merge");
         return 1;
     }
     if (starting) {
@@ -151,7 +151,7 @@ async function commandTrack(parsed) {
     await (0, config_js_1.writeLink)(folder, { ...link, track: wanted });
     console.log(dim("This folder now saves to ") + accent(wanted));
     if (existing) {
-        console.log(dim("Its files are not here yet — fetch them with ") + `coderook get`);
+        console.log(dim("Its files are not here yet — fetch them with ") + `cbx get`);
     }
     return 0;
 }