@coderook/cli 0.33.1 → 0.34.0

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.1",
+  "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.