@coderook/cli 0.33.0 → 0.34.0

package/dist/cli/src/git_remote.js

@@ -934,7 +934,7 @@ depth = null) {
         await (0, promises_1.rm)(scratch, { recursive: true, force: true });
     }
 }
-async function doPush(requests, url) {
+async function doPush(requests, url, options = {}) {
     /*
       A push never goes to the account named in the URL — it goes to the one the
       token belongs to. Publishing somebody's work to a different account on
@@ -988,6 +988,19 @@ async function doPush(requests, url) {
         if (!repositoryId)
             repositoryId = (await (0, api_js_1.findProject)(slug))?.id ?? null;
         state = repositoryId ? await remoteState(repositoryId) : null;
+        /*
+          A clone knows commits the messages do not name: the ones it built when
+          it imported each version. Counted as published, so a branch started in
+          a clone forks from the version it was cloned at — and a clone of a
+          project saved with `cbx submit` is not mistaken for unrelated history.
+        */
+        if (state && marks) {
+            for (const [versionId, mark] of marks.ofVersion) {
+                const sha = marks.sha.get(mark);
+                if (sha && !state.versionOfSha.has(sha))
+                    state.versionOfSha.set(sha, versionId);
+            }
+        }
     };
     const knownRefs = () => {
         const found = new Map();
@@ -1154,11 +1167,36 @@ async function doPush(requests, url) {
               the ordinary act of pushing a second branch to a project git already
               owns, which is the common case and not a conflict of any kind.
             */
+            /*
+              Unless the person says this repository *is* that project.
+      
+              The usual way here is a working repository whose CodeRook project was
+              started with `cbx submit` or the desktop app: same files, different
+              history. Refusing outright sent people to make a second project, which
+              is the duplicate this exists to prevent. `-o adopt` takes the middle
+              road: the project's saves stay as they are, this commit's tree is saved
+              on top as one save that names the commit, and from then on the project
+              and the repository agree, so later pushes add one save per commit.
+            */
+            let adopting = null;
             if (state && !already && state.versionCount > 0 && state.versionOfSha.size === 0) {
-                send(`error ${request.dst} the project "${slug}" already has ${state.versionCount} version${state.versionCount === 1 ? "" : "s"} that did not come from git; pushing would publish this history a second time`);
-                say(`\n  Push to a new project instead:\n` +
-                    `    git remote set-url coderook coderook://<a-new-name>\n`);
-                continue;
+                const line = state.tracks.find((candidate) => candidate.name === branch && candidate.kind === "line");
+                if (options.adopt && line?.headVersionId) {
+                    adopting = { headVersionId: line.headVersionId };
+                    say(`  adopting "${slug}": its ${state.versionCount} save${state.versionCount === 1 ? "" : "s"} stay as they are;` +
+                        ` ${tip.slice(0, 8)} is saved on top as one save,\n  and later pushes add one save per commit.`);
+                }
+                else {
+                    send(`error ${request.dst} the project "${slug}" already has ${state.versionCount} version${state.versionCount === 1 ? "" : "s"} that did not come from git; pushing would publish this history a second time`);
+                    say(options.adopt
+                        ? `\n  The project has no line called "${branch}" to adopt. Push the branch it saves on, usually main.\n`
+                        : `\n  If this repository holds that project, save it on top and link the two:\n` +
+                            `    git push -o adopt coderook ${branch}\n` +
+                            `  Your git history is not replayed; the commit you push becomes one save,\n` +
+                            `  and every push after it sends one save per commit.\n\n` +
+                            `  Or start from the project instead: git clone coderook://${slug}\n`);
+                    continue;
+                }
             }
             /*
               A branch the project has never seen starts at the newest commit it
@@ -1173,10 +1211,12 @@ async function doPush(requests, url) {
             }
             const from = already ?? fork?.sha ?? null;
             const range = from ? `${from}..${tip}` : tip;
-            const commits = git(["rev-list", "--reverse", "--topo-order", range])
-                .split("\n")
-                .map((line) => line.trim())
-                .filter(Boolean);
+            const commits = adopting
+                ? [tip]
+                : git(["rev-list", "--reverse", "--topo-order", range])
+                    .split("\n")
+                    .map((line) => line.trim())
+                    .filter(Boolean);
             if (!commits.length) {
                 /*
                   Nothing to publish does not mean nothing to do. A branch whose tip
@@ -1236,7 +1276,14 @@ async function doPush(requests, url) {
             let previous = git_history_js_1.EMPTY_TREE;
             let currentRepositoryId = repositoryId;
             let published = 0;
-            if (from && repositoryId && state) {
+            if (adopting && repositoryId) {
+                baseVersionId = adopting.headVersionId;
+                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 };
+            }
+            else if (from && repositoryId && state) {
                 previous = from;
                 if (already) {
                     const track = state.tracks.find((candidate) => candidate.name === branch && candidate.kind === "line");
@@ -1281,6 +1328,17 @@ async function doPush(requests, url) {
                 }
                 const changes = await applyCommit(catFile, scratch, previous, sha);
                 previous = sha;
+                if (adopting) {
+                    /*
+                      The commit's tree is the whole truth: what the project holds and
+                      the commit does not is removed, exactly as a later push would.
+                    */
+                    const inTree = new Set(git(["ls-tree", "-r", "-z", "--name-only", sha]).split("\0").filter(Boolean));
+                    for (const file of Object.keys(manifest)) {
+                        if (!inTree.has(file) && !changes.deleted.includes(file))
+                            changes.deleted.push(file);
+                    }
+                }
                 if (changes.skipped.length) {
                     say(`  skipped ${changes.skipped.length} submodule path(s) in ${sha.slice(0, 8)}`);
                 }
@@ -1463,6 +1521,8 @@ async function main(argv) {
     let unservable = false;
     /** `git clone --depth N`, when git passed one. */
     let depth = null;
+    /** `git push -o adopt`. */
+    let adopt = false;
     for await (const line of lines()) {
         const command = line.trim();
         if (command === "capabilities") {
@@ -1486,6 +1546,11 @@ async function main(argv) {
                 depth = Number(value);
                 send("ok");
             }
+            else if (name === "push-option" && value === "adopt") {
+                /* `git push -o adopt`: see the adopting note in doPush. */
+                adopt = true;
+                send("ok");
+            }
             else {
                 send("unsupported");
             }
@@ -1633,7 +1698,7 @@ async function main(argv) {
                     send("");
                     continue;
                 }
-                await doPush(batch, url);
+                await doPush(batch, url, { adopt });
             }
             continue;
         }

package/dist/cli/src/local_commands.js

@@ -32,6 +32,7 @@ const repository_js_1 = require("../../cbx/src/local/repository.js");
 const remote_js_1 = require("../../cbx/src/local/remote.js");
 const api_js_1 = require("./api.js");
 const config_js_1 = require("./config.js");
+const project_choice_js_1 = require("./project_choice.js");
 const project_commands_js_1 = require("./project_commands.js");
 const publish_js_1 = require("./publish.js");
 const ESC = String.fromCharCode(27);
@@ -363,11 +364,31 @@ async function recordLink(repository, line, repositoryId, head, manifest) {
 async function localPush(parsed, repository) {
     return reporting(async () => {
         const link = await (0, config_js_1.readLink)(repository.root);
+        /*
+          A history that has never been pushed, in a folder linked to nothing,
+          is asked which project it belongs to, as `cbx submit` asks: naming it
+          after the folder joined any project that shared the name.
+        */
+        let chosen = null;
+        if (!link && !(await (0, remote_js_1.readRemote)(repository)).repositoryId) {
+            const into = parsed.flags.get("into");
+            const named = parsed.flags.get("name");
+            chosen = await (0, project_choice_js_1.chooseProject)({
+                folder: repository.root,
+                name: typeof named === "string" ? named : node_path_1.default.basename(repository.root),
+                ...(typeof into === "string" ? { into } : {}),
+                startNew: has(parsed, "new"),
+                command: "cbx push",
+            });
+            if (!chosen)
+                return 1;
+        }
         const interactive = node_process_1.default.stdout.isTTY;
         const result = await (0, remote_js_1.push)(repository, {
             credentials: config_js_1.credentials,
-            projectName: link?.slug ?? node_path_1.default.basename(repository.root),
-            repositoryId: link?.repositoryId ?? null,
+            projectName: link?.slug ?? (chosen ? ("id" in chosen ? chosen.slug : chosen.name) : node_path_1.default.basename(repository.root)),
+            repositoryId: link?.repositoryId ?? (chosen && "id" in chosen ? chosen.id : null),
+            joinExisting: false,
             allowSecrets: has(parsed, "allow-secrets"),
             acknowledged: has(parsed, "yes", "y"),
             report: (event) => {

package/dist/cli/src/mcp.js

@@ -23,6 +23,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.commandMcp = commandMcp;
+const node_fs_1 = require("node:fs");
 const promises_1 = require("node:fs/promises");
 const node_os_1 = __importDefault(require("node:os"));
 const node_path_1 = __importDefault(require("node:path"));
@@ -236,9 +237,17 @@ const TOOLS = [
                 : node_process_1.default.cwd());
             const link = await (0, config_js_1.readLink)(folder);
             const rules = await (0, worktree_js_1.readRules)(folder);
-            const changed = await (0, worktree_js_1.changedFiles)(folder, rules, null);
+            /*
+              Measured against what the folder last held, as `cbx status` measures.
+              Passing nothing here called every file in the folder new.
+            */
+            const baseline = link?.manifest
+                ? new Map(Object.entries(link.local ?? link.manifest))
+                : null;
+            const changed = await (0, worktree_js_1.changedFiles)(folder, rules, baseline);
+            const saving = howToSave(folder, link?.slug ?? null);
             if (!changed.length)
-                return "Nothing here has changed since the last version.";
+                return `Nothing here has changed since the last version.\n${saving}`;
             /*
               Said in the words the scan actually produces: a file the folder no
               longer has is a deletion, one with nothing removed is new, and the
@@ -256,10 +265,37 @@ const TOOLS = [
                 lines.push(`… and ${changed.length - lines.length} more`);
             }
             const where = link ? `${link.slug} (v${link.sequence})` : "not linked to a project";
-            return `${folder} — ${where}\n${changed.length} changed\n${lines.join("\n")}`;
+            return `${folder} — ${where}\n${changed.length} changed\n${lines.join("\n")}\n${saving}`;
         },
     },
 ];
+/**
+ * Which way this folder is saved, said to the assistant reading the status.
+ *
+ * Saving stays something a person agrees to, so this names the command and
+ * runs nothing. A git repository is pointed at git: each commit then keeps its
+ * own message, where `cbx submit` would make one snapshot of all of them.
+ */
+function howToSave(folder, slug) {
+    let config = null;
+    try {
+        config = (0, node_fs_1.readFileSync)(node_path_1.default.join(folder, ".git", "config"), "utf8");
+    }
+    catch {
+        /* Not a git repository. */
+    }
+    if (config !== null) {
+        const remote = config.match(/\[remote "([^"]+)"\][^[]*?url\s*=\s*coderook:/);
+        if (remote)
+            return `To save: commit, then git push ${remote[1]} <branch> (ask first).`;
+        return (`This is a git repository with no CodeRook remote. To save each commit: ` +
+            `git remote add coderook coderook://${slug ?? "<project>"}, then git push coderook <branch> ` +
+            `(git push -o adopt the first time if the project was saved with cbx submit). Ask first.`);
+    }
+    if (slug)
+        return `To save: cbx submit -m "…" (ask first).`;
+    return `Not linked. To save, ask which project it is: cbx submit --into <project> or cbx submit --new.`;
+}
 /* ------------------------------------------------------------------ wire */
 function reply(id, result) {
     node_process_1.default.stdout.write(`${JSON.stringify({ jsonrpc: "2.0", id, result })}\n`);

package/dist/cli/src/project_choice.js

@@ -0,0 +1,122 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.likenessLine = likenessLine;
+exports.chooseProject = chooseProject;
+/*
+  Which project an unlinked folder's first save goes into, decided by the
+  person rather than by a name that happens to match.
+
+  Shared by `cbx submit` and a local history's first `cbx push`: both used to
+  name the project after the folder, join it if the account already had one
+  of that name, and start a new one otherwise, without a word either way.
+*/
+const promises_1 = require("node:readline/promises");
+const node_process_1 = __importDefault(require("node:process"));
+const api_js_1 = require("./api.js");
+const config_js_1 = require("./config.js");
+const folder_match_js_1 = require("./folder_match.js");
+const download_js_1 = require("../../cbx/src/core/download.js");
+const ESC = String.fromCharCode(27);
+const colour = node_process_1.default.stdout.isTTY && !node_process_1.default.env.NO_COLOR;
+const paint = (code) => (value) => colour ? `${ESC}[${code}m${value}${ESC}[0m` : value;
+const dim = paint("2");
+const red = paint("31");
+const accent = paint("33");
+/**
+ * One line about a project an unlinked folder might be, with how much of it
+ * is here: the number that tells a stale copy from a separate project.
+ */
+async function likenessLine(folder, like, width) {
+    const { project } = like;
+    let here = "";
+    if (project.versionCount) {
+        try {
+            const downloader = new download_js_1.Downloader(config_js_1.credentials);
+            const latest = (await downloader.versions(project.id))[0];
+            if (latest) {
+                const paths = (await downloader.files(project.id, latest.id)).map((file) => file.path);
+                here = ` · ${(0, folder_match_js_1.pathsPresent)(folder, paths)} of its ${paths.length} files are here at the same path`;
+            }
+        }
+        catch {
+            /* The list is still worth showing without the count. */
+        }
+    }
+    return (`${accent(project.slug.padEnd(width))}  v${project.versionCount}` +
+        dim(`${here}${like.sameName ? " · same name as this folder" : ""}`));
+}
+/**
+ * `--into` and `--new` say it outright, which is what a script or an
+ * assistant must do. Without either, a folder whose name is like a project
+ * already on the account is asked about at a terminal and refused elsewhere,
+ * with the two commands that would settle it. A name like nothing on the
+ * account is a new project, as it always was.
+ *
+ * Returns the project to save into, a new project's name, or null to stop.
+ */
+async function chooseProject(input) {
+    const { folder, name, into, startNew, command } = input;
+    if (into && startNew) {
+        console.error(red("Pass --into or --new, not both."));
+        return null;
+    }
+    if (into) {
+        const project = await (0, api_js_1.findProject)(into);
+        if (!project) {
+            console.error(red(`No project matching "${into}" on your account.`));
+            console.error(dim(`  ${accent("cbx projects")} lists them.`));
+            return null;
+        }
+        return project;
+    }
+    const likes = (0, folder_match_js_1.similarProjects)(await (0, api_js_1.projects)(), name);
+    const taken = likes.find((like) => like.sameName);
+    if (startNew) {
+        if (!taken)
+            return { name };
+        console.error(red(`Your account already has a project called ${taken.project.slug}.`));
+        console.error(dim("  Save into it with ") + accent(`--into ${taken.project.slug}`) +
+            dim(", or give the new one another name with ") + accent("--name <name>") + dim("."));
+        return null;
+    }
+    if (!likes.length)
+        return { name };
+    const width = Math.max(...likes.map((like) => like.project.slug.length));
+    const lines = await Promise.all(likes.map((like) => likenessLine(folder, like, width)));
+    const interactive = Boolean(node_process_1.default.stdin.isTTY && node_process_1.default.stdout.isTTY);
+    const say = interactive ? console.log : console.error;
+    say(`This folder is not linked to a project, and your account has ${likes.length === 1 ? "one" : "some"} like it:`);
+    lines.forEach((line, at) => say(`  ${interactive ? `${at + 1}  ` : ""}${line}`));
+    if (!interactive) {
+        console.error(`\nNothing was sent. Say which:`);
+        console.error(`  ${accent(`${command} --into ${likes[0].project.slug}`)}   ${dim("save into that project")}`);
+        console.error(`  ${accent(`${command} --new${taken ? " --name <another-name>" : ""}`)}   ${dim("start a separate project")}`);
+        return null;
+    }
+    const reader = (0, promises_1.createInterface)({ input: node_process_1.default.stdin, output: node_process_1.default.stdout });
+    try {
+        const answer = (await reader.question(`\nSave into one of these (its number), start a new project (n), or stop (Enter): `)).trim().toLowerCase();
+        const picked = Number(answer);
+        if (Number.isInteger(picked) && picked >= 1 && picked <= likes.length) {
+            return likes[picked - 1].project;
+        }
+        if (answer !== "n" && answer !== "new")
+            return null;
+        if (!taken)
+            return { name };
+        const other = (await reader.question(`Name for the new project: `)).trim();
+        if (!other)
+            return null;
+        if (likes.some((like) => like.project.slug === (0, folder_match_js_1.slugFor)(other))) {
+            console.error(red(`${(0, folder_match_js_1.slugFor)(other)} is taken too.`));
+            return null;
+        }
+        return { name: other };
+    }
+    finally {
+        reader.close();
+    }
+}

package/dist/cli/src/publish.js

@@ -13,6 +13,7 @@ function uploadRequestFor(input) {
         message: input.message,
         projectName: input.projectName,
         repositoryId: input.repositoryId,
+        ...(input.joinExisting === false ? { joinExisting: false } : {}),
         baseVersionId: input.baseVersionId,
         ...(input.track ? { track: input.track } : {}),
         ...(input.allowIgnored ? { allowIgnored: true } : {}),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@coderook/cli",
-  "version": "0.33.0",
+  "version": "0.34.0",
   "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",

package/skills/coderook/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: coderook
-description: Save, browse and restore versions of a project on CodeRook — a version host where every version is a complete snapshot and there is no git to learn. Use when asked to save or submit work to CodeRook, check what has changed, look at a project's versions or files, fetch a project, start or switch a line of work, or resolve a save that landed at the same time as somebody else's.
+description: Save, browse and restore versions of a project on CodeRook — a version host where every version is a complete snapshot, reached with the cbx command or with plain git. Use when asked to save, submit or push work to CodeRook, check what has changed, look at a project's versions or files, fetch a project, start or switch a line of work, or resolve a save that landed at the same time as somebody else's.
 allowed-tools: Bash Read
 ---
 
@@ -11,7 +11,13 @@ project had at that moment, so restoring one never depends on the versions
 around it, and there is no staging area, no branches to rebase and no history
 to rewrite.
 
-Everything here is the `coderook` command line. Run it with Bash.
+Everything here is the `cbx` command line (also installed as `coderook`), or
+git itself through CodeRook's remote helper. Run them with Bash.
+
+**Which one to use.** If the folder is a git repository (`git rev-parse` works
+in it), prefer git — see *Working in a git repository* below. Each commit then
+arrives with its own message, instead of one snapshot standing in for many.
+Use `cbx submit` for folders that are not git repositories.
 
 ## Before anything else
 
@@ -44,6 +50,21 @@ nothing.
 cbx submit -m "What changed, in a sentence"
 ```
 
+**The first save from a folder must say which project it is.** A folder that
+is not linked goes to a new project named after it — unless the account has a
+project with a name like it, and then `submit` stops and lists them. Do not
+guess: show the person the list and ask. Then run one of:
+
+```bash
+cbx submit --into <project> -m "…"   # this folder is that project
+cbx submit --new -m "…"              # a separate project (add --name if the name is taken)
+cbx link <project>                   # link only; send nothing yet
+```
+
+Never start a second project for work that already has one. A folder copied to
+another machine, another operating system or another path is still the same
+project: `cbx link` it.
+
 Send only what changed; the version still names every file. Write the message
 yourself from the actual diff rather than asking for one — a message like
 "update" helps nobody reading the history later.
@@ -56,6 +77,33 @@ explain. Propose it, say what it would send, and let them agree.
 that freely; it is safe and it is the honest way to answer "what would this
 upload?".
 
+## Working in a git repository
+
+CodeRook is a git remote. `npm install --global @coderook/cli` puts the helper
+(`git-remote-coderook`) on PATH; the plugin and `npx` do not, so check with
+`git ls-remote coderook://<project>` before relying on it.
+
+```bash
+git remote -v                                        # is there a coderook:// remote already?
+git remote add coderook coderook://<project>         # if not
+git push coderook main                               # each new commit becomes a save
+git push coderook <branch>                           # a branch becomes a line
+git push coderook v1.2.0                             # a tag names a version
+git fetch coderook                                   # bring other people's saves in
+```
+
+If the project was started with `cbx submit` or the desktop app, the first push
+is refused with a message saying so. When the repository holds that project,
+`git push -o adopt coderook main` saves the current commit on top of what is
+there, once; plain pushes work from then on. **Ask before adopting** — it is a
+save like any other. If the project is somebody else's work under the same
+name, push to a new name instead.
+
+Git's limits here: no force pushes or branch deletions (saves are permanent), a
+merge commit arrives as one save holding the merged tree, and a commit holding
+a credential is refused — take the key out of history rather than looking for
+a way round.
+
 ## Fetching
 
 ```bash
@@ -234,6 +282,20 @@ file with its size, SHA-256 and `url`. Updaters have no account, so the
 project they read must be public; keep private code in a separate project and
 ship releases from a public one.
 
+## Building executables for every platform
+
+```bash
+cbx build --plan                  # how this machine would build each target
+cbx build --target win,linux,mac  # build them into .coderook/build/<target>/
+```
+
+It builds on this machine, with the tools it has, and uploads nothing. Run
+`--plan` first and read it out: a target marked "no" says what would build it
+(Docker, a Mac, cargo-zigbuild) — pass that on rather than installing things
+unasked. `--ship` attaches the results to the newest save, so **ask before
+`--ship`**, as before any save. A project's own build description lives in
+`coderook.build.json`.
+
 ## Things not to do
 
 - Do not run `cbx delete` unless the person has asked for that project to
@@ -242,6 +304,8 @@ ship releases from a public one.
   again and gains nothing.
 - Do not guess a project name. `cbx projects` lists them; a folder that is
   already linked needs no name at all.
+- Do not pass `--new` to get past the question `submit` asks. It exists for a
+  separate project the person wants, not to avoid choosing.
 - Do not run `cbx take-down`. It destroys the files in a version and they do
   not come back. Say it exists and let its owner run it.