@coderook/cli 0.33.1 → 0.34.0

package/dist/cli/src/cli.js

@@ -28,6 +28,7 @@ const help_js_1 = require("./help.js");
 const progress_js_1 = require("./progress.js");
 const publish_js_1 = require("./publish.js");
 const attach_command_js_1 = require("./attach_command.js");
+const build_command_js_1 = require("./build_command.js");
 const pages_command_js_1 = require("./pages_command.js");
 const project_commands_js_1 = require("./project_commands.js");
 const track_commands_js_1 = require("./track_commands.js");
@@ -52,6 +53,8 @@ const profile_js_1 = require("../../cbx/src/core/profile.js");
 const detect_js_1 = require("../../cbx/src/core/detect.js");
 const cbx_js_1 = require("../../cbx/src/core/cbx.js");
 const api_js_2 = require("./api.js");
+const folder_match_js_1 = require("./folder_match.js");
+const project_choice_js_1 = require("./project_choice.js");
 const import_command_js_1 = require("./import_command.js");
 const runner_js_1 = require("./runner.js");
 const config_js_1 = require("./config.js");
@@ -203,11 +206,22 @@ const folderFor = (parsed, index = 0) => node_path_1.default.resolve(parsed.posi
  */
 async function reconcile(folder, options = {}) {
     const link = await (0, config_js_1.readLink)(folder);
-    const reference = link?.slug ?? node_path_1.default.basename(folder);
+    /*
+      A folder that is not linked is not linked.
+  
+      This used to look the folder's name up and link it to whatever answered,
+      from any command — `status` included, and straight after `cbx unlink`.
+      That is how an inner folder named like its parent's project was saved into
+      it, laying a second copy of the app over the project's root. Which project
+      a folder belongs to is a question for the person, asked where it matters.
+    */
+    if (!link && !options.adopt) {
+        return { link: null, baseline: null, behind: null, member: true };
+    }
     let member = true;
     let project = link
         ? (await (0, api_js_2.projects)()).find((candidate) => candidate.id === link.repositoryId)
-        : await (0, api_js_2.findProject)(reference);
+        : options.adopt;
     /*
       Not on the account's own list, which holds only projects it is in. A
       folder cloned from somebody else's public project is exactly that, and
@@ -291,9 +305,11 @@ async function reconcile(folder, options = {}) {
         local: Object.fromEntries(baseline),
         manifest: Object.fromEntries(baseline),
     };
-    await (0, config_js_1.writeLink)(folder, fresh);
-    if (!options.quiet && !link) {
-        console.log(dim(`Linked this folder to ${project.slug}.`));
+    if (options.persist !== false) {
+        await (0, config_js_1.writeLink)(folder, fresh);
+        if (!options.quiet && !link) {
+            console.log(dim(`Linked this folder to ${project.slug}.`));
+        }
     }
     return { link: fresh, baseline, behind: null, member };
 }
@@ -358,7 +374,35 @@ async function commandUnlink(parsed) {
     console.log(`Detached ${bold(node_path_1.default.basename(folder))}` +
         (link?.slug ? dim(` from ${link.slug}`) : "") +
         ".");
-    console.log(dim("Nothing was deleted. Submitting from here now starts a new project."));
+    console.log(dim("Nothing was deleted. The next submit from here asks which project it is."));
+    return 0;
+}
+async function commandLink(parsed) {
+    const reference = parsed.positional[0];
+    if (!reference) {
+        console.error(red("Say which project: cbx link <project> [folder]"));
+        return 1;
+    }
+    const folder = folderFor(parsed, 1);
+    const already = await (0, config_js_1.readLink)(folder);
+    if (already) {
+        console.error(red(`This folder is already linked to ${already.slug}.`));
+        console.error(dim(`  Run ${accent("cbx unlink")} first to link it somewhere else.`));
+        return 1;
+    }
+    const project = await (0, api_js_2.findProject)(reference);
+    if (!project) {
+        console.error(red(`No project matching "${reference}" on your account.`));
+        return 1;
+    }
+    const { link } = await reconcile(folder, { adopt: project, quiet: true });
+    if (!link) {
+        console.error(red(`${project.slug} has nothing saved yet, so there is nothing to link to.`));
+        console.error(dim(`  Save into it with ${accent(`cbx submit --into ${project.slug}`)}.`));
+        return 1;
+    }
+    console.log(`Linked ${bold(node_path_1.default.basename(folder))} to ${accent(project.slug)}` + dim(` at v${link.sequence}`) + ".");
+    console.log(dim(`  ${accent("cbx status")} shows how this folder differs from it; nothing was sent or fetched.`));
     return 0;
 }
 async function commandStatus(parsed) {
@@ -395,7 +439,21 @@ async function commandStatus(parsed) {
     console.log(bold(node_path_1.default.basename(folder)) + dim(`  ${folder}`));
     console.log(link
         ? `Account holds ${accent(`v${link.sequence}`)} · ${Object.keys(link.manifest).length} files ${dim(`(${link.slug})`)}`
-        : dim("Not on your account yet — submitting will create it."));
+        : dim("This folder is not linked to a project."));
+    if (!link) {
+        const likes = (0, folder_match_js_1.similarProjects)(await (0, api_js_2.projects)().catch(() => []), node_path_1.default.basename(folder));
+        if (likes.length) {
+            const width = Math.max(...likes.map((like) => like.project.slug.length));
+            console.log(dim("Projects on your account like it:"));
+            for (const like of likes)
+                console.log(`  ${await (0, project_choice_js_1.likenessLine)(folder, like, width)}`);
+            console.log(dim("Link it with ") + accent(`cbx link ${likes[0].project.slug}`) +
+                dim(", or start a separate project with ") + accent('cbx submit --new -m "…"') + dim("."));
+        }
+        else {
+            console.log(dim("Submitting will create a project for it."));
+        }
+    }
     /*
       A folder can have nothing to send and still not hold the whole version:
       when the service merges somebody else's save into yours, their files
@@ -592,6 +650,9 @@ async function commandImport(parsed) {
     */
     if (!submitFlags.has("name"))
         submitFlags.set("name", plan.name);
+    /* An import is a new project; one already called this is said, not joined. */
+    if (!submitFlags.has("into"))
+        submitFlags.set("new", true);
     if (!submitFlags.has("m") && !submitFlags.has("message")) {
         submitFlags.set("message", `Imported from ${url}`);
     }
@@ -606,6 +667,28 @@ async function commandImport(parsed) {
     }
     return code;
 }
+/**
+ * Say so when this folder is a git repository with no CodeRook remote.
+ *
+ * Every save from one is a snapshot that forgets the commits it holds, and an
+ * assistant told only about `cbx submit` never learns there is another way:
+ * the remote helper, which saves each commit with its message. One line,
+ * after the save, and only until the remote exists.
+ */
+function noteGitRoute(folder, slug) {
+    try {
+        const config = (0, node_fs_1.readFileSync)(node_path_1.default.join(folder, ".git", "config"), "utf8");
+        if (/coderook:/.test(config))
+            return;
+    }
+    catch {
+        return;
+    }
+    const name = slug ?? "<project>";
+    console.log(dim("This is a git repository. To save each commit with its message instead of snapshots: ") +
+        accent(`git remote add coderook coderook://${name}`) + dim(" then ") +
+        accent("git push -o adopt coderook main") + dim(" once, and plain git push after."));
+}
 /** A file's SHA-256, streamed; null when it cannot be read. */
 async function digestOfFile(full) {
     try {
@@ -651,7 +734,38 @@ async function commandSubmit(parsed) {
         return 1;
     }
     const dryRun = hasFlag(parsed, "dry-run", "n");
-    const { link, baseline, behind, member } = await reconcile(folder);
+    /*
+      Which project this goes into is settled before anything is scanned, and
+      by the person: a folder that is not linked is never joined to a project
+      because their names agree, nor quietly made into a second copy of one.
+    */
+    const already = await (0, config_js_1.readLink)(folder);
+    let adopt;
+    const intoFlag = flagText(parsed, "into");
+    if (already && (hasFlag(parsed, "new") || (intoFlag && (0, folder_match_js_1.slugFor)(intoFlag.split("/").pop()) !== already.slug))) {
+        console.error(red(`This folder is already linked to ${already.slug}.`));
+        console.error(dim(`  Run ${accent("cbx unlink")} first to save it somewhere else.`));
+        return 1;
+    }
+    if (!already) {
+        const chosen = await (0, project_choice_js_1.chooseProject)({
+            folder,
+            name: flagText(parsed, "name") ?? node_path_1.default.basename(folder),
+            ...(intoFlag ? { into: intoFlag } : {}),
+            startNew: hasFlag(parsed, "new"),
+            command: "cbx submit",
+        });
+        if (!chosen)
+            return 1;
+        if ("id" in chosen)
+            adopt = chosen;
+        else
+            parsed.flags.set("name", chosen.name);
+    }
+    const { link, baseline, behind, member } = await reconcile(folder, {
+        ...(adopt ? { adopt } : {}),
+        persist: !dryRun,
+    });
     /*
       Somebody else's project, cloned from its public page. Reading and
       fetching are fine; saving into it is not this account's to do, and the
@@ -680,8 +794,8 @@ async function commandSubmit(parsed) {
       A dry run changes nothing, and that includes writing a LICENSE: it says
       what would be added instead.
     */
-    const wouldLicence = dryRun && !link && !hasFlag(parsed, "no-licence") && !(0, node_fs_1.existsSync)(node_path_1.default.join(folder, "LICENSE"));
-    const added = link || dryRun
+    const wouldLicence = dryRun && !link && !adopt && !hasFlag(parsed, "no-licence") && !(0, node_fs_1.existsSync)(node_path_1.default.join(folder, "LICENSE"));
+    const added = link || adopt || dryRun
         ? null
         : await (0, licence_commands_js_1.licenceNewProject)(folder, 
         /*
@@ -928,8 +1042,13 @@ Pass ${accent("--allow-secrets")} if these are not real keys.`);
           wins: renaming somebody's project because they passed a flag would be
           a surprise, and the flag exists for projects that do not exist yet.
         */
-        projectName: link?.slug ?? flagText(parsed, "name") ?? node_path_1.default.basename(folder),
-        repositoryId: link?.repositoryId ?? null,
+        projectName: link?.slug ?? adopt?.slug ?? flagText(parsed, "name") ?? node_path_1.default.basename(folder),
+        repositoryId: link?.repositoryId ?? adopt?.id ?? null,
+        /*
+          Settled above, so a project that appears under this name between the
+          question and the save is a collision to report, not one to join.
+        */
+        joinExisting: false,
         // Every current CLI publish states its ancestry. A brand-new project is
         // explicitly based on an empty Track; a linked folder names the immutable
         // Version it was last reconciled with.
@@ -1195,6 +1314,7 @@ The connection failed: ${text}`));
         */
         ` · the save holds ${bytes(result.sourceBytes)}`);
     noteKeptDeletions(folder, baseline, hasFlag(parsed, "sync"));
+    noteGitRoute(folder, link?.slug ?? adopt?.slug ?? (0, folder_match_js_1.slugFor)(flagText(parsed, "name") ?? node_path_1.default.basename(folder)));
     /*
       Where the time went, when asked for.
   
@@ -1226,6 +1346,8 @@ async function commandGet(parsed) {
     const { link } = await reconcile(folder);
     if (!link) {
         console.error(red("This folder is not linked to a project on your account."));
+        console.error(dim("  Link it with ") + accent("cbx link <project>") +
+            dim(", or fetch a project into a new folder with ") + accent("cbx clone <project>") + dim("."));
         return 1;
     }
     /*
@@ -2093,7 +2215,10 @@ const SPECS = [
         usage: 'submit [folder] -m "…"',
         detail: "Sends everything that changed since the last save. If the folder is\n" +
             "not linked to a project yet, one is created on your account, named\n" +
-            "after the folder and private to begin with.\n\n" +
+            "after the folder and private to begin with — unless your account\n" +
+            "already has a project with a name like it. Then you are asked which\n" +
+            "you mean, and a script or assistant must say: --into <project> saves\n" +
+            "into it, --new starts a separate one.\n\n" +
             "A save is not a version. Nobody outside the project can see one until\n" +
             "it is named, which is what `cbx release` does — so submitting is as\n" +
             "cheap and as private as you want it to be.",
@@ -2104,6 +2229,14 @@ const SPECS = [
                 flags: "--name <name>",
                 description: "name a new project this, instead of after the folder",
             },
+            {
+                flags: "--into <project>",
+                description: "first save from this folder: save into this project and link the folder to it",
+            },
+            {
+                flags: "--new",
+                description: "first save from this folder: start a new project even if one has a similar name",
+            },
             {
                 flags: "--allow-secrets",
                 description: "send files that look like credentials, and files with keys inside",
@@ -2123,6 +2256,7 @@ const SPECS = [
         ],
         examples: [
             'cbx submit -m "Fix the export dialog"',
+            'cbx submit --into voxai-coder -m "First save from the Linux machine"',
             'cbx submit --track spike -m "Try the other encoder"',
         ],
         run: commandSubmit,
@@ -2239,6 +2373,20 @@ const SPECS = [
         examples: ["cbx switch", "cbx switch -c spike", "cbx switch main"],
         run: (0, local_commands_js_1.localFirst)(local_commands_js_1.localSwitch, track_commands_js_1.commandTrack),
     },
+    {
+        name: "link",
+        group: "Working with a folder",
+        summary: "connect this folder to a project already on your account",
+        usage: "link <project> [folder]",
+        detail: "Says which project this folder is a copy of, without sending or\n" +
+            "fetching anything. Use it for a folder that holds a project you saved\n" +
+            "from somewhere else — another machine, another operating system, or a\n" +
+            "copy made by hand — so its next save goes into that project instead\n" +
+            "of starting a new one. Files that differ here are what the next save\n" +
+            "sends; `cbx status` shows them first.",
+        examples: ["cbx link voxai-coder", "cbx link my-project ./copy"],
+        run: commandLink,
+    },
     {
         name: "unlink",
         group: "Working with a folder",
@@ -3154,6 +3302,34 @@ function localTwin(name, original, local, row, extra) {
         run: (0, local_commands_js_1.localFirst)(local, spec.run),
     };
 }
+SPECS.push({
+    name: "build",
+    group: "Actions",
+    summary: "build executables for Windows, Linux and macOS on this machine",
+    usage: "build [folder] [--target win,linux,mac]",
+    detail: "Builds the project in this folder for each target, using whatever this\n" +
+        "machine has: Go, Bun, Deno and .NET build every platform from any one;\n" +
+        "Rust does with cargo-zigbuild; Electron builds Windows and Linux in\n" +
+        "Docker; PyInstaller builds Linux in Docker or WSL. A target this machine\n" +
+        "cannot build is named, with what would build it. Nothing is uploaded\n" +
+        "unless --ship is given. Output goes to .coderook/build/<target>/.\n\n" +
+        "The toolchain is recognised from the files here. To fix it, or to give\n" +
+        "a command of your own, describe the build in coderook.build.json\n" +
+        "(cbx build init writes one), which is saved with the project.",
+    options: [
+        { flags: "-t, --target <list>", description: "windows-x64, linux-arm64, macos-arm64 … or win, linux, mac, all" },
+        { flags: "--plan", description: "say how each target would be built, build nothing" },
+        { flags: "--preset <name>", description: "go, bun, deno, rust, dotnet, electron, pyinstaller or custom" },
+        { flags: "--ship", description: "attach what was built to the project's newest save" },
+    ],
+    examples: [
+        "cbx build --plan",
+        "cbx build --target win,linux,mac",
+        "cbx build --target all --ship",
+        "cbx build init",
+    ],
+    run: build_command_js_1.commandBuild,
+});
 SPECS.push(localTwin("push", "submit", local_commands_js_1.localPush, {
     summary: "send this line's saves to CodeRook",
     usage: "push",

package/dist/cli/src/config.js

@@ -402,6 +402,12 @@ async function forgetLink(localPath) {
         await writePrivate(storedFileFor(key), JSON.stringify(forgotten));
     }
     await (0, promises_1.rm)(folderLinkFile(localPath), { force: true });
+    /* The folder CodeRook made for the link goes too, unless it holds anything else. */
+    const directory = node_path_1.default.dirname(folderLinkFile(localPath));
+    const left = await (0, promises_1.readdir)(directory).catch(() => null);
+    if (left && left.length === 1 && left[0] === ".gitignore") {
+        await (0, promises_1.rm)(directory, { recursive: true, force: true });
+    }
     return true;
 }
 async function writeLink(localPath, link) {

package/dist/cli/src/folder_match.js

@@ -0,0 +1,62 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.slugFor = slugFor;
+exports.similarProjects = similarProjects;
+exports.pathsPresent = pathsPresent;
+/*
+  Which of the account's projects a folder that is not linked might be.
+
+  A save from an unlinked folder used to decide this alone: a project with the
+  folder's name was joined without a word, and anything else started a new
+  project without one either. Both went wrong on a real account. An inner
+  folder called `voxai-coder` was joined to the project of the same name and
+  laid a second copy of the app over its root for thirteen versions; a Linux
+  machine that did not know the folder was linked started `voxai-coder-linux`
+  beside it. Neither was a choice anybody made.
+
+  So this only finds the candidates. Choosing between them is the person's.
+*/
+const node_fs_1 = require("node:fs");
+const node_path_1 = __importDefault(require("node:path"));
+/** The slug the service gives a name: what a new project would be called. */
+function slugFor(name) {
+    return (name
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-|-$/g, "") || "project");
+}
+/**
+ * Projects whose name is this one, or this one with a word added or taken
+ * away: `voxai-coder` finds `voxai-coder-linux`, and the other way round.
+ *
+ * Words, not letters. `app` is not like `apple`, and a project somebody
+ * named `wallpaper-picker-backend` on purpose is offered, never assumed.
+ */
+function similarProjects(all, name) {
+    const wanted = slugFor(name);
+    const related = (slug) => slug.startsWith(`${wanted}-`) || wanted.startsWith(`${slug}-`);
+    return all
+        .filter((project) => project.slug === wanted || related(project.slug))
+        .map((project) => ({ project, sameName: project.slug === wanted }))
+        .sort((left, right) => Number(right.sameName) - Number(left.sameName))
+        .slice(0, 5);
+}
+/**
+ * How many of a project's files are in this folder at the same path.
+ *
+ * Paths only, and only counted: reading every file to compare digests would
+ * make the question cost a full scan, and a folder that holds most of a
+ * project's paths is already the answer somebody needs to choose.
+ */
+function pathsPresent(folder, paths) {
+    let present = 0;
+    for (const file of paths) {
+        if ((0, node_fs_1.existsSync)(node_path_1.default.join(folder, ...file.split("/"))))
+            present += 1;
+    }
+    return present;
+}

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`);