@coderook/cli 0.33.1 → 0.34.1

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/node_check.js

@@ -0,0 +1,26 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MINIMUM_NODE = void 0;
+exports.nodeTooOld = nodeTooOld;
+/*
+  The Node this needs, said before anything else runs.
+
+  The package said Node 20.11, and that was wrong: bundles and local histories
+  use zstd, which Node gained in 23.8 and 22.15. On Linux, Node 22.12 got as
+  far as reading a project and then died with
+  "(0 , node_zlib_1.zstdDecompressSync) is not a function", which names
+  nothing anybody can act on.
+*/
+const node_process_1 = __importDefault(require("node:process"));
+const node_zlib_1 = __importDefault(require("node:zlib"));
+exports.MINIMUM_NODE = "22.15";
+/** A sentence for a Node that is too old, or null when this one will do. */
+function nodeTooOld() {
+    if (typeof node_zlib_1.default.zstdDecompressSync === "function")
+        return null;
+    return (`CodeRook needs Node ${exports.MINIMUM_NODE} or later; this is Node ${node_process_1.default.versions.node} (${node_process_1.default.execPath}).\n` +
+        `Install a current Node (https://nodejs.org), or put a newer one first on your PATH.`);
+}

package/dist/cli/src/portable_python.js

@@ -0,0 +1,370 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UV_PLATFORM = exports.PYTHON_TRIPLE = void 0;
+exports.tarEntry = tarEntry;
+exports.renamedEntries = renamedEntries;
+exports.scriptOf = scriptOf;
+exports.runtimeRequirements = runtimeRequirements;
+exports.buildPortablePython = buildPortablePython;
+/**
+ * A Python program built for another system, without that system.
+ *
+ * PyInstaller freezes a program with the interpreter it runs under, so it
+ * only ever builds for the machine it is on — which left Python as the one
+ * language `cbx build` could not take to Linux from Windows. This assembles
+ * the same result from parts instead:
+ *
+ * - the target system's own CPython, from python-build-standalone (the
+ *   relocatable builds uv and others use), checked against its published
+ *   SHA-256;
+ * - the program's dependencies as the target system's wheels, resolved by
+ *   uv for that platform — environment markers included, which pip with
+ *   `--platform` gets wrong because it evaluates them for this machine;
+ * - the program's own files, and a launcher.
+ *
+ * Out comes `<name>-<target>.tar.gz`: one folder holding `python/`, `lib/`,
+ * `app/` and the launcher, with every program in it marked executable. The
+ * interpreter's archive is never unpacked here — its symlinks would not
+ * survive Windows — its entries are carried across with their paths renamed.
+ *
+ * The limit is a package that publishes no wheel for the target: there is no
+ * compiler for another system here, and uv says so by name.
+ */
+const node_child_process_1 = require("node:child_process");
+const node_crypto_1 = require("node:crypto");
+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"));
+const node_process_1 = __importDefault(require("node:process"));
+const node_zlib_1 = require("node:zlib");
+const rules_js_1 = require("../../cbx/src/core/rules.js");
+const worktree_js_1 = require("../../cbx/src/core/worktree.js");
+/** python-build-standalone's name for each system. */
+exports.PYTHON_TRIPLE = {
+    "windows-x64": "x86_64-pc-windows-msvc",
+    "windows-arm64": "aarch64-pc-windows-msvc",
+    "linux-x64": "x86_64-unknown-linux-gnu",
+    "linux-arm64": "aarch64-unknown-linux-gnu",
+    "macos-x64": "x86_64-apple-darwin",
+    "macos-arm64": "aarch64-apple-darwin",
+};
+/**
+ * uv's name for the platform wheels are chosen for. Linux asks for glibc 2.28
+ * (Debian 10, Ubuntu 20.04, RHEL 8 and later), which is where most projects'
+ * wheels are built now; older wheels still qualify.
+ */
+exports.UV_PLATFORM = {
+    "windows-x64": "x86_64-pc-windows-msvc",
+    "windows-arm64": "aarch64-pc-windows-msvc",
+    "linux-x64": "x86_64-manylinux_2_28",
+    "linux-arm64": "aarch64-manylinux_2_28",
+    "macos-x64": "x86_64-apple-darwin",
+    "macos-arm64": "aarch64-apple-darwin",
+};
+/* ------------------------------------------------------------------ tar */
+function octal(value, width) {
+    return `${value.toString(8).padStart(width - 1, "0")}\0`;
+}
+function checksum(header) {
+    header.fill(0x20, 148, 156);
+    let sum = 0;
+    for (const byte of header)
+        sum += byte;
+    header.write(`${sum.toString(8).padStart(6, "0")}\0 `, 148, 8, "latin1");
+}
+/** Where a path goes in a ustar header: name alone, or prefix and name. */
+function splitName(full) {
+    if (Buffer.byteLength(full) <= 100)
+        return { prefix: "", name: full };
+    for (let at = full.indexOf("/"); at !== -1; at = full.indexOf("/", at + 1)) {
+        const prefix = full.slice(0, at);
+        const name = full.slice(at + 1);
+        if (Buffer.byteLength(prefix) <= 155 && Buffer.byteLength(name) <= 100 && name)
+            return { prefix, name };
+    }
+    return null;
+}
+/** A pax header carrying a path too long for ustar. */
+function paxFor(full) {
+    let record = ` path=${full}\n`;
+    let length = Buffer.byteLength(record);
+    /* The record counts its own length digits. */
+    while (Buffer.byteLength(`${length}${record}`) !== length)
+        length = Buffer.byteLength(`${length}${record}`);
+    const body = Buffer.from(`${length}${record}`);
+    const header = Buffer.alloc(512);
+    header.write("PaxHeader", 0);
+    header.write(octal(0o644, 8), 100, "latin1");
+    header.write(octal(0, 8), 108, "latin1");
+    header.write(octal(0, 8), 116, "latin1");
+    header.write(octal(body.length, 12), 124, "latin1");
+    header.write(octal(0, 12), 136, "latin1");
+    header.write("x", 156, "latin1");
+    header.write("ustar\0", 257, "latin1");
+    header.write("00", 263, "latin1");
+    checksum(header);
+    return Buffer.concat([header, body, Buffer.alloc((512 - (body.length % 512)) % 512)]);
+}
+function setName(header, full) {
+    header.fill(0, 0, 100);
+    header.fill(0, 345, 500);
+    const split = splitName(full);
+    if (split) {
+        header.write(split.name, 0, 100, "utf8");
+        header.write(split.prefix, 345, 155, "utf8");
+        return [];
+    }
+    header.write(full.slice(-99), 0, 100, "utf8");
+    return [paxFor(full)];
+}
+/** One file, or a symlink, as tar bytes. */
+function tarEntry(full, body, mode, link) {
+    const header = Buffer.alloc(512);
+    const before = setName(header, full);
+    header.write(octal(mode, 8), 100, "latin1");
+    header.write(octal(0, 8), 108, "latin1");
+    header.write(octal(0, 8), 116, "latin1");
+    header.write(octal(link ? 0 : body.length, 12), 124, "latin1");
+    header.write(octal(Math.floor(Date.now() / 1000), 12), 136, "latin1");
+    header.write(link ? "2" : "0", 156, "latin1");
+    if (link)
+        header.write(link, 157, 100, "utf8");
+    header.write("ustar\0", 257, "latin1");
+    header.write("00", 263, "latin1");
+    checksum(header);
+    const data = link ? [] : [body, Buffer.alloc((512 - (body.length % 512)) % 512)];
+    return Buffer.concat([...before, header, ...data]);
+}
+/**
+ * Every entry of a ustar archive, renamed under `top/`, header by header.
+ * Bodies and link targets are untouched, so symlinks and modes survive.
+ */
+function renamedEntries(archive, top) {
+    const out = [];
+    let at = 0;
+    while (at + 512 <= archive.length) {
+        const header = Buffer.from(archive.subarray(at, at + 512));
+        if (header.every((byte) => byte === 0))
+            break;
+        const field = (start, length) => header.subarray(start, start + length).toString("utf8").replace(/\0.*$/s, "");
+        const size = parseInt(field(124, 12).trim() || "0", 8);
+        const type = String.fromCharCode(header[156] ?? 48);
+        const span = 512 + Math.ceil(size / 512) * 512;
+        if (type === "x" || type === "g" || type === "L" || type === "K") {
+            throw new Error("the interpreter archive uses long-name headers this does not rewrite");
+        }
+        const prefix = field(345, 155);
+        const name = prefix ? `${prefix}/${field(0, 100)}` : field(0, 100);
+        const before = setName(header, `${top}/${name}`);
+        checksum(header);
+        out.push(...before, header, Buffer.from(archive.subarray(at + 512, at + span)));
+        at += span;
+    }
+    return out;
+}
+const isProgram = (body) => (body[0] === 0x7f && body.toString("latin1", 1, 4) === "ELF") ||
+    body.toString("latin1", 0, 2) === "#!" ||
+    (body.length >= 4 && [0xfeedfacf, 0xcafebabe, 0xbebafeca].includes(body.readUInt32LE(0)));
+/* ------------------------------------------------------------- runtime */
+function run(program, args, options = {}) {
+    return new Promise((done) => {
+        let out = "";
+        const child = (0, node_child_process_1.spawn)(program, args, { windowsHide: true, stdio: ["ignore", "pipe", "pipe"] });
+        child.stdout.on("data", (chunk) => {
+            out += chunk;
+            if (!options.quiet)
+                node_process_1.default.stdout.write(chunk);
+        });
+        child.stderr.on("data", (chunk) => {
+            out += chunk;
+            if (!options.quiet)
+                node_process_1.default.stderr.write(chunk);
+        });
+        child.on("error", (error) => done({ code: 1, out: error.message }));
+        child.on("exit", (code) => done({ code: code ?? 1, out }));
+    });
+}
+/** uv on PATH, or one installed into the cache with this machine's pip. */
+async function findUv(cache) {
+    if ((await run("uv", ["--version"], { quiet: true })).code === 0)
+        return "uv";
+    const local = node_path_1.default.join(cache, "uv", "bin", node_process_1.default.platform === "win32" ? "uv.exe" : "uv");
+    if ((0, node_fs_1.existsSync)(local))
+        return local;
+    for (const python of ["python3", "python"]) {
+        const installed = await run(python, ["-m", "pip", "install", "--quiet", "--disable-pip-version-check", "--target", node_path_1.default.join(cache, "uv"), "uv"], { quiet: true });
+        if (installed.code === 0 && (0, node_fs_1.existsSync)(local))
+            return local;
+    }
+    throw new Error("needs uv (https://docs.astral.sh/uv) or Python with pip to fetch it");
+}
+/** The target's CPython, downloaded once, checked against its published digest. */
+async function pythonRuntime(cache, version, target, say) {
+    const folder = node_path_1.default.join(cache, "python");
+    await (0, promises_1.mkdir)(folder, { recursive: true });
+    const wanted = new RegExp(`^cpython-${version.replace(".", "\\.")}\\.\\d+\\+\\d+-${exports.PYTHON_TRIPLE[target]}-install_only\\.tar\\.gz$`);
+    const cached = (await (0, promises_1.readdir)(folder)).find((name) => wanted.test(name));
+    if (cached)
+        return (0, promises_1.readFile)(node_path_1.default.join(folder, cached));
+    const release = (await (await fetch("https://api.github.com/repos/astral-sh/python-build-standalone/releases/latest", {
+        headers: { accept: "application/vnd.github+json", "user-agent": "coderook-cli" },
+    })).json());
+    const asset = (release.assets ?? []).find((one) => wanted.test(one.name));
+    if (!asset)
+        throw new Error(`no CPython ${version} build for ${target} in the latest python-build-standalone release`);
+    if (!asset.digest?.startsWith("sha256:"))
+        throw new Error("the release does not publish a digest for it");
+    say(`Fetching ${asset.name}…`);
+    const body = Buffer.from(await (await fetch(asset.browser_download_url)).arrayBuffer());
+    if ((0, node_crypto_1.createHash)("sha256").update(body).digest("hex") !== asset.digest.slice("sha256:".length)) {
+        throw new Error("the download does not match its published digest");
+    }
+    await (0, promises_1.writeFile)(node_path_1.default.join(folder, asset.name), body);
+    return body;
+}
+/* ------------------------------------------------------------- project */
+/** The script PyInstaller would freeze: from a .spec's Analysis, or the file itself. */
+function scriptOf(entry, specText = "") {
+    if (!entry.endsWith(".spec"))
+        return entry;
+    const found = specText.match(/Analysis\(\s*\[\s*(?:r)?['"]([^'"]+)['"]/);
+    if (!found)
+        throw new Error(`could not find the script in ${entry}; set "entry" to it`);
+    /* A spec written on Windows escapes its backslashes: `src\\app\\main.py`. */
+    return found[1].replace(/\\+/g, "/");
+}
+/** Requirements, minus the build tools that freeze rather than run the program. */
+function runtimeRequirements(text) {
+    return text
+        .split(/\r?\n/)
+        .filter((line) => !/^\s*(pyinstaller|pyinstaller-hooks-contrib|nuitka|cx[-_]freeze)\b/i.test(line))
+        .join("\n");
+}
+const SKIP = new Set([...rules_js_1.UNCOUNTED_DIRECTORIES, "__pycache__", "build", "dist", "venv", ".venv", "env", "node_modules", ".mypy_cache", ".pytest_cache", ".tox"]);
+/** The program's own files, as the project's ignore rules see them. */
+async function appFiles(folder) {
+    const rules = await (0, worktree_js_1.readRules)(folder);
+    const layers = [{ base: "", rules: (0, rules_js_1.parseRules)(`${rules.shared}\n${rules.local}`) }];
+    const found = [];
+    const walk = async (relative) => {
+        for (const entry of await (0, promises_1.readdir)(node_path_1.default.join(folder, relative), { withFileTypes: true })) {
+            const rel = relative ? `${relative}/${entry.name}` : entry.name;
+            if (entry.isDirectory()) {
+                if (SKIP.has(entry.name) || (0, rules_js_1.excludes)(rel, true, layers))
+                    continue;
+                await walk(rel);
+            }
+            else if (entry.isFile() && !(0, rules_js_1.excludes)(rel, false, layers) && !/\.(pyc|pyo|spec)$/.test(entry.name)) {
+                found.push(rel);
+            }
+        }
+    };
+    await walk("");
+    return found;
+}
+async function buildPortablePython(request) {
+    const say = request.say ?? ((text) => console.log(text));
+    const { folder, target } = request;
+    const windows = target.startsWith("windows");
+    const top = `${request.name}-${target}`;
+    const hostVersion = (await run("python3", ["-c", "import sys;print('%d.%d'%sys.version_info[:2])"], { quiet: true }));
+    const hostVersionAlt = hostVersion.code === 0 ? hostVersion : await run("python", ["-c", "import sys;print('%d.%d'%sys.version_info[:2])"], { quiet: true });
+    const version = request.python ?? (hostVersionAlt.code === 0 ? hostVersionAlt.out.trim() : "3.12");
+    const script = scriptOf(request.entry, request.entry.endsWith(".spec") ? await (0, promises_1.readFile)(node_path_1.default.join(folder, request.entry), "utf8") : "");
+    if (!(0, node_fs_1.existsSync)(node_path_1.default.join(folder, script)))
+        throw new Error(`${script} is not in the project`);
+    const runtime = (0, node_zlib_1.gunzipSync)(await pythonRuntime(request.cache, version, target, say));
+    const uv = await findUv(request.cache);
+    /* Dependencies, as the target's wheels. */
+    const scratch = await (0, promises_1.mkdtemp)(node_path_1.default.join(node_os_1.default.tmpdir(), "coderook-pybuild-"));
+    try {
+        const lib = node_path_1.default.join(scratch, "lib");
+        await (0, promises_1.mkdir)(lib);
+        let requirements = "";
+        if ((0, node_fs_1.existsSync)(node_path_1.default.join(folder, "requirements.txt"))) {
+            requirements = runtimeRequirements(await (0, promises_1.readFile)(node_path_1.default.join(folder, "requirements.txt"), "utf8"));
+        }
+        if (requirements.trim()) {
+            const file = node_path_1.default.join(scratch, "requirements.txt");
+            await (0, promises_1.writeFile)(file, requirements);
+            say(`Resolving dependencies for ${target} (${exports.UV_PLATFORM[target]}, Python ${version})…`);
+            const installed = await run(uv, [
+                "pip", "install", "--quiet", "--target", lib,
+                "--python-platform", exports.UV_PLATFORM[target], "--python-version", version,
+                /* No building from source: it would build for this machine, not the target. */
+                "--no-build", "-r", file,
+            ]);
+            if (installed.code !== 0) {
+                throw new Error(/no wheels|--no-build|only-binary|has no wheel/i.test(installed.out)
+                    ? `a dependency publishes no ${target} wheel, and it cannot be compiled for ${target} here; build on that system instead`
+                    : "resolving the dependencies failed (above)");
+            }
+        }
+        const entries = renamedEntries(runtime, top);
+        const add = async (base, prefix, skipTop = new Set()) => {
+            const walk = async (relative) => {
+                for (const entry of await (0, promises_1.readdir)(node_path_1.default.join(base, relative), { withFileTypes: true })) {
+                    const rel = relative ? `${relative}/${entry.name}` : entry.name;
+                    if (!relative && skipTop.has(entry.name))
+                        continue;
+                    if (entry.isDirectory()) {
+                        if (entry.name === "__pycache__")
+                            continue;
+                        await walk(rel);
+                    }
+                    else if (entry.isFile()) {
+                        const body = await (0, promises_1.readFile)(node_path_1.default.join(base, rel));
+                        entries.push(tarEntry(`${top}/${prefix}/${rel}`, body, isProgram(body) ? 0o755 : 0o644));
+                    }
+                }
+            };
+            await walk("");
+        };
+        /* uv writes console scripts for this machine into bin/; they are not the target's. */
+        await add(lib, "lib", new Set(["bin"]));
+        for (const rel of await appFiles(folder)) {
+            const body = await (0, promises_1.readFile)(node_path_1.default.join(folder, rel));
+            entries.push(tarEntry(`${top}/app/${rel}`, body, isProgram(body) ? 0o755 : 0o644));
+        }
+        if (windows) {
+            const python = request.gui ? "pythonw.exe" : "python.exe";
+            const launcher = [
+                "@echo off",
+                "setlocal",
+                'set "HERE=%~dp0"',
+                'set "PYTHONPATH=%HERE%lib;%HERE%app"',
+                "set PYTHONNOUSERSITE=1",
+                `${request.gui ? 'start "" ' : ""}"%HERE%python\\${python}" "%HERE%app\\${script.replace(/\//g, "\\")}" %*`,
+                "",
+            ].join("\r\n");
+            entries.push(tarEntry(`${top}/${request.name}.cmd`, Buffer.from(launcher), 0o755));
+        }
+        else {
+            const launcher = [
+                "#!/bin/sh",
+                "# Runs the program with the Python beside it. Made by cbx build.",
+                'here="$(cd "$(dirname "$0")" && pwd -P)"',
+                /* Exported, not prefixed: assignments before `exec` are not passed on by every sh. */
+                'PYTHONPATH="$here/lib:$here/app${PYTHONPATH:+:$PYTHONPATH}"',
+                "PYTHONNOUSERSITE=1",
+                "export PYTHONPATH PYTHONNOUSERSITE",
+                `exec "$here/python/bin/python3" "$here/app/${script}" "$@"`,
+                "",
+            ].join("\n");
+            entries.push(tarEntry(`${top}/${request.name}`, Buffer.from(launcher), 0o755));
+        }
+        entries.push(Buffer.alloc(1024));
+        await (0, promises_1.mkdir)(request.outFolder, { recursive: true });
+        const archive = node_path_1.default.join(request.outFolder, `${top}.tar.gz`);
+        await (0, promises_1.writeFile)(archive, (0, node_zlib_1.gzipSync)(Buffer.concat(entries), { level: 9 }));
+        say(`Wrote ${node_path_1.default.basename(archive)} (${((await (0, promises_1.stat)(archive)).size / 1024 ** 2).toFixed(1)} MB): unpack it and run ${windows ? `${request.name}.cmd` : `./${request.name}`}.`);
+        return archive;
+    }
+    finally {
+        await (0, promises_1.rm)(scratch, { recursive: true, force: true });
+    }
+}

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.1",
   "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",
@@ -20,7 +20,7 @@
     "gamedev"
   ],
   "engines": {
-    "node": ">=20.11.0"
+    "node": ">=22.15.0"
   },
   "bin": {
     "cbx": "dist/cli/src/cli.js",