@coderook/cli 0.33.0 → 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, 
         /*
@@ -899,7 +1013,7 @@ Pass ${accent("--allow-secrets")} if these are not real keys.`);
         console.log("");
     }
     const line = progressLine();
-    const uploader = new upload_js_1.Uploader(config_js_1.credentials);
+    let uploader = new upload_js_1.Uploader(config_js_1.credentials);
     /*
       Built by the shared description, so this and the git remote helper cannot
       drift. They already had: the helper listed deletions in `deletions` alone
@@ -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.
@@ -1001,71 +1120,99 @@ Pass ${accent("--allow-secrets")} if these are not real keys.`);
         }
     }
     let result;
-    try {
-        const plan = await uploader.plan(uploadRequest, (progress) => {
-            line(`  ${track(progress.percent)} ${String(progress.percent).padStart(3)}%  ` +
-                `${"plan".padEnd(7)} ${progress.files}/${progress.totalFiles}  ` +
-                dim(progress.path.slice(-40)));
-        });
-        done(line);
-        console.log(`${accent("Upload plan")}  ${bytes(plan.sourceBytes)} selected → ` +
-            `${bytes(plan.compactedBytes)} compacted; ${bytes(plan.chargeableBytes)} new storage.`);
-        console.log(plan.allowance.exempt
-            ? dim("Annual plan: the monthly staged upload allowance does not apply.")
-            : dim(`Monthly stage ${plan.allowance.stage}: ${plan.allowance.unlockedPercent}% unlocked, ` +
-                `${bytes(plan.allowance.remainingBytes)} remains after this reservation.`));
-        if (dryRun) {
-            await uploader.cancelPlan(plan, true);
-            const going = files.filter((file) => !file.deleted);
-            const removing = files.filter((file) => file.deleted);
-            console.log(`${going.length} file${going.length === 1 ? "" : "s"} would be sent or reused:`);
-            for (const file of going)
-                console.log(`  ${file.path}`);
-            if (removing.length) {
-                console.log(`${removing.length} file${removing.length === 1 ? "" : "s"} would be removed from the save:`);
-                for (const file of removing)
-                    console.log(`  ${red("deleted")} ${file.path}`);
+    /*
+      How long to wait before picking a dropped upload up again by itself.
+  
+      Each request is already retried for a few seconds, but a Wi-Fi drop or a
+      router reconnecting outlasts that, and the upload ended with "run the same
+      command again" for somebody to notice and act on. Running it again was
+      always safe and cheap (pieces already stored are recognised and skipped,
+      and the save itself is named so it can never be made twice), so the
+      command now does it itself, a few times, before giving up.
+    */
+    const resumeAfter = [10, 30, 60];
+    for (let resumed = 0;; resumed += 1) {
+        try {
+            const plan = await uploader.plan(uploadRequest, (progress) => {
+                line(`  ${track(progress.percent)} ${String(progress.percent).padStart(3)}%  ` +
+                    `${"plan".padEnd(7)} ${progress.files}/${progress.totalFiles}  ` +
+                    dim(progress.path.slice(-40)));
+            });
+            done(line);
+            console.log(`${accent("Upload plan")}  ${bytes(plan.sourceBytes)} selected → ` +
+                `${bytes(plan.compactedBytes)} compacted; ${bytes(plan.chargeableBytes)} new storage.`);
+            console.log(plan.allowance.exempt
+                ? dim("Annual plan: the monthly staged upload allowance does not apply.")
+                : dim(`Monthly stage ${plan.allowance.stage}: ${plan.allowance.unlockedPercent}% unlocked, ` +
+                    `${bytes(plan.allowance.remainingBytes)} remains after this reservation.`));
+            if (dryRun) {
+                await uploader.cancelPlan(plan, true);
+                const going = files.filter((file) => !file.deleted);
+                const removing = files.filter((file) => file.deleted);
+                console.log(`${going.length} file${going.length === 1 ? "" : "s"} would be sent or reused:`);
+                for (const file of going)
+                    console.log(`  ${file.path}`);
+                if (removing.length) {
+                    console.log(`${removing.length} file${removing.length === 1 ? "" : "s"} would be removed from the save:`);
+                    for (const file of removing)
+                        console.log(`  ${red("deleted")} ${file.path}`);
+                }
+                noteKeptDeletions(folder, baseline, hasFlag(parsed, "sync"));
+                console.log("Nothing was uploaded and no Version was created.");
+                return 0;
             }
-            noteKeptDeletions(folder, baseline, hasFlag(parsed, "sync"));
-            console.log("Nothing was uploaded and no Version was created.");
-            return 0;
+            result = await uploader.execute(uploadRequest, plan, (progress) => {
+                line(`  ${track(progress.percent)} ${String(progress.percent).padStart(3)}%  ` +
+                    `${progress.stage.padEnd(7)} ${progress.files}/${progress.totalFiles}  ` +
+                    dim(progress.path.slice(-40)));
+            });
+            break;
         }
-        result = await uploader.execute(uploadRequest, plan, (progress) => {
-            line(`  ${track(progress.percent)} ${String(progress.percent).padStart(3)}%  ` +
-                `${progress.stage.padEnd(7)} ${progress.files}/${progress.totalFiles}  ` +
-                dim(progress.path.slice(-40)));
-        });
-    }
-    catch (error) {
-        done(line);
-        /*
-          Classified by the shared description rather than by a private regular
-          expression, so a push and a submit disagree about nothing — including
-          what counts as "the connection failed" and what that means for whether
-          the work was saved.
-        */
-        const failure = (0, publish_js_1.classifyPublishFailure)(error);
-        const text = (0, network_js_1.describeError)(error);
-        if (failure?.kind === "interrupted") {
-            console.error(red(`
-The connection failed: ${text}`));
-            console.error(`Your work may already have been saved. Run the same command again —` +
-                ` it will not create a second version.`);
-            return 1;
-        }
-        if (failure?.kind === "conflict") {
+        catch (error) {
+            done(line);
             /*
-              Somebody else saved to this project first. Everything that did not
-              overlap has already been combined by the service; what is left is a
-              genuine decision, so the answer is to bring their work down and look
-              at it rather than to try again harder.
+              Classified by the shared description rather than by a private regular
+              expression, so a push and a submit disagree about nothing — including
+              what counts as "the connection failed" and what that means for whether
+              the work was saved.
             */
-            console.error(red(error instanceof Error ? error.message : String(error)));
-            console.error(`\nRun ${accent("cbx get")} to bring the latest version down, then` +
-                ` submit again. Nothing was changed on your account.`);
-            return 1;
+            const failure = (0, publish_js_1.classifyPublishFailure)(error);
+            const text = (0, network_js_1.describeError)(error);
+            if (failure?.kind === "interrupted" && !dryRun && resumed < resumeAfter.length) {
+                const wait = resumeAfter[resumed];
+                console.error(dim(`The connection dropped (${text})`));
+                console.error(dim(`Picking the upload up again in ${wait}s (try ${resumed + 2} of ${resumeAfter.length + 1}).` +
+                    ` Pieces already sent are kept; only the rest goes.`));
+                /*
+                  The failed attempt's other lanes are still retrying; stopped first, so
+                  they do not carry on sending beside the attempt that replaces them.
+                */
+                uploader.cancel();
+                await (0, network_js_1.pause)(wait * 1000);
+                uploader = new upload_js_1.Uploader(config_js_1.credentials);
+                continue;
+            }
+            if (failure?.kind === "interrupted") {
+                console.error(red(`
+The connection failed: ${text}`));
+                console.error(`Your work may already have been saved. Run the same command again —` +
+                    ` it will not create a second version.`);
+                return 1;
+            }
+            if (failure?.kind === "conflict") {
+                /*
+                  Somebody else saved to this project first. Everything that did not
+                  overlap has already been combined by the service; what is left is a
+                  genuine decision, so the answer is to bring their work down and look
+                  at it rather than to try again harder.
+                */
+                console.error(red(error instanceof Error ? error.message : String(error)));
+                console.error(`\nRun ${accent("cbx get")} to bring the latest version down, then` +
+                    ` submit again. Nothing was changed on your account.`);
+                return 1;
+            }
+            throw error;
         }
-        throw error;
     }
     done(line);
     if (result.mergeTrack) {
@@ -1167,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.
   
@@ -1198,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;
     }
     /*
@@ -2065,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.",
@@ -2076,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",
@@ -2095,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,
@@ -2211,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",
@@ -3126,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;
+}