@coderook/cli 0.22.2 → 0.24.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/import_command.js

@@ -0,0 +1,150 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.projectNameFromUrl = projectNameFromUrl;
+exports.looksLikeRepositoryUrl = looksLikeRepositoryUrl;
+exports.gitAvailable = gitAvailable;
+exports.fetchSnapshot = fetchSnapshot;
+exports.measure = measure;
+exports.humanBytes = humanBytes;
+const node_child_process_1 = require("node:child_process");
+const promises_1 = require("node:fs/promises");
+const node_os_1 = require("node:os");
+const node_path_1 = __importDefault(require("node:path"));
+const node_util_1 = require("node:util");
+const run = (0, node_util_1.promisify)(node_child_process_1.execFile);
+/**
+ * The repository's own name, from the last path segment.
+ *
+ * Deliberately not the host: an address with no path at all is not a
+ * repository, and naming somebody's project `github.com` because the URL was
+ * incomplete is the sort of thing they would only notice later.
+ */
+function projectNameFromUrl(url) {
+    const trimmed = url.trim().replace(/\/+$/, "");
+    /* Drop the scheme and authority so only path segments remain. */
+    const withoutScheme = trimmed.replace(/^[a-z][a-z0-9+.-]*:\/\//i, "");
+    const afterHost = /^[^/]*:/.test(withoutScheme)
+        ? /* scp-style git@host:owner/name */
+            withoutScheme.slice(withoutScheme.indexOf(":") + 1)
+        : withoutScheme.slice(withoutScheme.indexOf("/") + 1);
+    const hasPath = withoutScheme.includes("/") || /^[^/]*:/.test(withoutScheme);
+    if (!hasPath)
+        return "imported-project";
+    const tail = afterHost.split("/").filter(Boolean).pop() ?? "";
+    const name = tail.replace(/\.git$/i, "").trim();
+    return name || "imported-project";
+}
+/**
+ * Refuse anything that is not a repository location.
+ *
+ * `git clone` will happily treat a local path as a source, and a URL typed
+ * with a scheme this does not expect is more likely a mistake than an
+ * intention. Being narrow here keeps the command from doing something
+ * surprising with an argument that was meant for something else.
+ */
+function looksLikeRepositoryUrl(url) {
+    const value = url.trim();
+    if (/^(https?|git|ssh):\/\//i.test(value))
+        return true;
+    /* scp-style: git@host:owner/name.git */
+    if (/^[A-Za-z0-9._-]+@[A-Za-z0-9.-]+:[^\s]+$/.test(value))
+        return true;
+    return false;
+}
+async function exists(target) {
+    try {
+        await (0, promises_1.access)(target);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function isEmptyDirectory(target) {
+    try {
+        const entries = await (0, promises_1.readdir)(target);
+        return entries.length === 0;
+    }
+    catch {
+        return true;
+    }
+}
+async function gitAvailable() {
+    try {
+        await run("git", ["--version"], { windowsHide: true });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Shallow-clone into a working folder and strip the Git metadata.
+ *
+ * Returns where the files landed. The caller publishes from there with the
+ * ordinary save path, so an import produces exactly the Version an ordinary
+ * save of the same files would.
+ */
+async function fetchSnapshot(url, into, log = () => { }) {
+    const name = projectNameFromUrl(url);
+    let folder;
+    let temporary = false;
+    if (into) {
+        folder = node_path_1.default.resolve(into);
+        if ((await exists(folder)) && !(await isEmptyDirectory(folder))) {
+            throw new Error(`${folder} already has files in it. Import needs an empty folder, ` +
+                `so that nothing here is overwritten by what arrives.`);
+        }
+    }
+    else {
+        const base = await (0, promises_1.mkdtemp)(node_path_1.default.join((0, node_os_1.tmpdir)(), "coderook-import-"));
+        folder = node_path_1.default.join(base, name);
+        temporary = true;
+    }
+    log(`Fetching ${url}`);
+    /*
+      --depth 1 for the reason in the header. --single-branch keeps it to the
+      default branch: an import takes a snapshot of one line of work, and
+      fetching every branch's tip would cost time to produce content this
+      command then discards.
+    */
+    await run("git", ["clone", "--depth", "1", "--single-branch", url, folder], { windowsHide: true, maxBuffer: 32 * 1024 * 1024 });
+    const gitDirectory = node_path_1.default.join(folder, ".git");
+    if (await exists(gitDirectory)) {
+        await (0, promises_1.rm)(gitDirectory, { recursive: true, force: true });
+    }
+    return { folder, name, temporary };
+}
+/** Total bytes and file count of the fetched tree, for the summary line. */
+async function measure(folder) {
+    let files = 0;
+    let bytes = 0;
+    const walk = async (directory) => {
+        for (const entry of await (0, promises_1.readdir)(directory, { withFileTypes: true })) {
+            const full = node_path_1.default.join(directory, entry.name);
+            if (entry.isDirectory()) {
+                await walk(full);
+                continue;
+            }
+            if (!entry.isFile())
+                continue;
+            files += 1;
+            bytes += (await (0, promises_1.stat)(full)).size;
+        }
+    };
+    await walk(folder);
+    return { files, bytes };
+}
+function humanBytes(value) {
+    const units = ["B", "KB", "MB", "GB", "TB"];
+    let size = value;
+    let unit = 0;
+    while (size >= 1024 && unit < units.length - 1) {
+        size /= 1024;
+        unit += 1;
+    }
+    return `${unit === 0 ? size : size.toFixed(size < 10 ? 2 : 1)} ${units[unit]}`;
+}

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;
 }

package/dist/desktop-app/src/main/tracks.js

@@ -77,8 +77,18 @@ class Tracks {
      * accept, so this passes the name through rather than pre-judging it —
      * a rule enforced in two places is a rule that will disagree with itself.
      */
-    async create(repositoryId, name) {
-        const body = await this.call(`/v1/repositories/${repositoryId}/tracks`, { method: "POST", body: JSON.stringify({ name }) });
+    async create(repositoryId, name, 
+    /*
+      Where the line starts, when the caller knows better than "wherever the
+      project is now". Somebody clicking New line means from here; a git branch
+      means from the version matching the commit it forked at, which is
+      usually not the head. Omitted keeps the original behaviour exactly.
+    */
+    fromVersionId) {
+        const body = await this.call(`/v1/repositories/${repositoryId}/tracks`, {
+            method: "POST",
+            body: JSON.stringify(fromVersionId ? { name, fromVersionId } : { name }),
+        });
         return body.track;
     }
     /** Merges that have not been applied or abandoned. */

package/dist/desktop-app/src/main/upload.js

@@ -327,7 +327,16 @@ class Uploader {
         // A version is a snapshot, not a delta, so it has to name every file in
         // the project — not merely the ones being sent this time. Anything
         // unchanged keeps the object the previous version already pointed at.
-        const rules = await (0, worktree_js_1.readRules)(request.localPath);
+        /*
+          An import filters nothing. The rules keep local mess out of a working
+          folder, but an imported tree is exactly what the source repository
+          tracked — there is no mess in it, and anything the source tracked in
+          spite of its own rules (which git does, for files committed before the
+          rule) would otherwise be dropped without being mentioned.
+        */
+        const rules = request.allowIgnored
+            ? { shared: "", local: "" }
+            : await (0, worktree_js_1.readRules)(request.localPath);
         /*
           Surveyed, not listed.
     
@@ -1152,6 +1161,7 @@ class Uploader {
                     ? {}
                     : { expectedHeadVersionId: request.expectedHeadVersionId }),
                 ...(request.track ? { track: request.track } : {}),
+                ...(request.allowIgnored ? { allowIgnored: true } : {}),
                 /*
                   Names this attempt so a retry after a lost connection is answered
                   with the version already made, rather than making a second one.