@coderook/cli 0.31.12 → 0.32.0

package/dist/cli/src/local_commands.js

@@ -0,0 +1,506 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.localHistory = localHistory;
+exports.localFirst = localFirst;
+exports.commandInit = commandInit;
+exports.commandSave = commandSave;
+exports.localStatus = localStatus;
+exports.localLog = localLog;
+exports.localDiff = localDiff;
+exports.commandRestore = commandRestore;
+exports.localSwitch = localSwitch;
+exports.localPush = localPush;
+exports.localPull = localPull;
+exports.localMerge = localMerge;
+/**
+ * The local history, from a terminal: `cbx init`, `save`, `restore`, and the
+ * local side of `status`, `diff`, `log` and `switch`.
+ *
+ * None of these talk to CodeRook. A folder with a `.cbx/` history answers
+ * `status`, `diff`, `log` and `switch` from it; a folder without one gets the
+ * account-backed commands those names have always meant, so nothing anybody
+ * already relies on changes until they run `cbx init`.
+ */
+const node_path_1 = __importDefault(require("node:path"));
+const node_process_1 = __importDefault(require("node:process"));
+const history_js_1 = require("../../cbx/src/local/history.js");
+const merge_js_1 = require("../../cbx/src/local/merge.js");
+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_commands_js_1 = require("./project_commands.js");
+const publish_js_1 = require("./publish.js");
+const ESC = String.fromCharCode(27);
+const paint = (code) => (value) => `${ESC}[${code}m${value}${ESC}[0m`;
+const dim = paint("2");
+const bold = paint("1");
+const red = paint("31");
+const green = paint("32");
+const accent = paint("33");
+const short = (id) => id.slice(0, 10);
+const plural = (count, one, many = `${one}s`) => `${count.toLocaleString()} ${count === 1 ? one : many}`;
+function text(parsed, ...names) {
+    for (const name of names) {
+        const value = parsed.flags.get(name);
+        if (typeof value === "string")
+            return value;
+    }
+    return undefined;
+}
+const has = (parsed, ...names) => names.some((name) => parsed.flags.has(name));
+function bytes(value) {
+    if (value >= 1024 ** 3)
+        return `${(value / 1024 ** 3).toFixed(2)} GB`;
+    if (value >= 1024 ** 2)
+        return `${(value / 1024 ** 2).toFixed(1)} MB`;
+    if (value >= 1024)
+        return `${(value / 1024).toFixed(0)} KB`;
+    return `${value} B`;
+}
+/** The history the working directory is in, if it is in one. */
+async function localHistory(from = node_process_1.default.cwd()) {
+    return repository_js_1.Repository.find(from);
+}
+/**
+ * A command that means the local history in a folder that has one, and what
+ * it has always meant everywhere else.
+ */
+function localFirst(local, otherwise, from = () => node_process_1.default.cwd()) {
+    return async (parsed) => {
+        const repository = await localHistory(from(parsed));
+        return repository ? local(parsed, repository) : otherwise(parsed);
+    };
+}
+function printChanges(changes, limit = 50) {
+    const rows = [
+        ...changes.added.map((file) => [green("added   "), file]),
+        ...changes.modified.map((file) => [accent("changed "), file]),
+        ...changes.deleted.map((file) => [red("deleted "), file]),
+    ].sort((left, right) => (left[1] < right[1] ? -1 : left[1] > right[1] ? 1 : 0));
+    for (const [mark, file] of rows.slice(0, limit))
+        console.log(`  ${mark}${file}`);
+    if (rows.length > limit)
+        console.log(dim(`  … and ${rows.length - limit} more`));
+}
+function describeSave(one) {
+    const when = new Date(one.created);
+    const date = Number.isNaN(when.getTime())
+        ? one.created
+        : when.toLocaleString(undefined, { dateStyle: "medium", timeStyle: "short" });
+    return `${accent(short(one.id))}  ${one.message.split("\n")[0]}  ${dim(`${one.author} · ${date}`)}`;
+}
+/** Refusals are printed as sentences, not stack traces. */
+async function reporting(work) {
+    try {
+        return await work();
+    }
+    catch (error) {
+        if (error instanceof remote_js_1.RemoteAhead || error instanceof remote_js_1.RemoteDiffers || error instanceof remote_js_1.NoRemote) {
+            console.error(red(error.message));
+            return 1;
+        }
+        const failure = (0, publish_js_1.classifyPublishFailure)(error);
+        if (failure?.kind === "credentials") {
+            console.error(red(failure.message));
+            console.error(dim("Take the key out of that save, or push it deliberately with --allow-secrets."));
+            return 1;
+        }
+        if (failure?.kind === "interrupted") {
+            console.error(red(`The connection failed part way: ${failure.message}`));
+            console.error(dim("Push again. Saves already on CodeRook are not sent twice."));
+            return 1;
+        }
+        if (error instanceof history_js_1.UnsavedChanges || error instanceof history_js_1.UnresolvedConflicts) {
+            console.error(red(error.message));
+            for (const file of error.files.slice(0, 20))
+                console.error(`  ${file}`);
+            if (error.files.length > 20)
+                console.error(dim(`  … and ${error.files.length - 20} more`));
+            return 1;
+        }
+        console.error(red(error instanceof Error ? error.message : String(error)));
+        return 1;
+    }
+}
+/* ---- init ------------------------------------------------------------ */
+async function commandInit(parsed) {
+    return reporting(async () => {
+        const folder = node_path_1.default.resolve(parsed.positional[0] ?? node_process_1.default.cwd());
+        const inside = await localHistory(folder);
+        if (inside && inside.root !== folder) {
+            console.error(red(`${folder} is already inside the history at ${inside.root}.`));
+            console.error(dim("One history per project. Run cbx commands from anywhere inside it."));
+            return 1;
+        }
+        const repository = await (0, history_js_1.init)(folder, text(parsed, "line") ?? undefined);
+        console.log(`Started a history in ${bold(repository.root)} on ${accent(await repository.currentLine())}.`);
+        console.log(dim("It lives in .cbx/ and never leaves this machine by itself. Run " +
+            `cbx save -m "…" to record the folder as it is.`));
+        return 0;
+    });
+}
+/* ---- save ------------------------------------------------------------ */
+async function commandSave(parsed) {
+    return reporting(async () => {
+        const repository = await repository_js_1.Repository.open(node_process_1.default.cwd());
+        const message = text(parsed, "m", "message") ?? "";
+        const merging = await (0, merge_js_1.readMergeState)(repository);
+        if (!message.trim() && !merging) {
+            console.error(red('A save needs a message: cbx save -m "what changed"'));
+            return 1;
+        }
+        const interactive = node_process_1.default.stdout.isTTY;
+        let shown = 0;
+        const result = await (0, history_js_1.save)(repository, {
+            message,
+            force: has(parsed, "force", "f"),
+            author: text(parsed, "author"),
+            progress: interactive
+                ? (done, total) => {
+                    const now = Date.now();
+                    if (now - shown < 100 && done < total)
+                        return;
+                    shown = now;
+                    node_process_1.default.stdout.write(`\r${dim(`Reading ${done.toLocaleString()} of ${total.toLocaleString()} files`)}   `);
+                }
+                : undefined,
+        });
+        if (interactive)
+            node_process_1.default.stdout.write(`\r${" ".repeat(60)}\r`);
+        if (!result.saved) {
+            console.log("Nothing has changed since the last save, so there is nothing to record.");
+            return 0;
+        }
+        const count = (0, history_js_1.changeCount)(result.changes);
+        console.log(`Saved ${accent(short(result.save.id))} on ${accent(result.save.line)}: ` +
+            `${result.save.message.split("\n")[0]}`);
+        console.log(dim(`${plural(count, "file")} changed · ${plural(result.files, "file")}, ` +
+            `${bytes(result.bytes)} in the save`));
+        printChanges(result.changes, 20);
+        return 0;
+    });
+}
+/* ---- status ---------------------------------------------------------- */
+async function localStatus(_parsed, repository) {
+    return reporting(async () => {
+        const now = await (0, history_js_1.status)(repository);
+        console.log(`${bold(node_path_1.default.basename(repository.root))} on ${accent(now.line)}` +
+            (now.head ? dim(`  last saved ${short(now.head.id)}: ${now.head.message.split("\n")[0]}`) : dim("  nothing saved yet")));
+        if (now.merging) {
+            const left = now.merging.unresolved.length;
+            console.log(`Merging ${accent(short(now.merging.theirs))}: ` +
+                (left ? red(`${plural(left, "file")} still ${left === 1 ? "has" : "have"} conflict markers`) : green("no conflict markers left")));
+            for (const conflict of now.merging.conflicts) {
+                const how = conflict.kind === "text"
+                    ? now.merging.unresolved.includes(conflict.path) ? "markers in it" : "edited"
+                    : conflict.kind === "binary"
+                        ? "both changed; this line's copy is in the folder"
+                        : conflict.kind === "deleted-here"
+                            ? "deleted here, changed there; their copy is in the folder"
+                            : "changed here, deleted there; this copy is in the folder";
+                console.log(`  ${red("conflict")} ${conflict.path}  ${dim(how)}`);
+            }
+            console.log(dim(`Finish with cbx save, take a side with cbx merge --mine or --theirs, or cbx merge --cancel.`));
+        }
+        const count = (0, history_js_1.changeCount)(now.changes);
+        if (!count) {
+            console.log("Nothing has changed since the last save.");
+            return 0;
+        }
+        console.log(`${plural(count, "file")} changed since the last save:`);
+        printChanges(now.changes);
+        console.log(dim(`cbx diff shows the lines; cbx save -m "…" records them.`));
+        return 0;
+    });
+}
+/* ---- log ------------------------------------------------------------- */
+async function localLog(parsed, repository) {
+    return reporting(async () => {
+        const limit = Number(text(parsed, "limit") ?? 20);
+        const saves = await (0, history_js_1.log)(repository, {
+            from: parsed.positional[0],
+            limit: Number.isFinite(limit) && limit > 0 ? limit : 20,
+        });
+        if (!saves.length) {
+            console.log(`Nothing saved on ${accent(await repository.currentLine())} yet.`);
+            return 0;
+        }
+        for (const one of saves)
+            console.log(describeSave(one));
+        return 0;
+    });
+}
+/* ---- diff ------------------------------------------------------------ */
+async function localDiff(parsed, repository) {
+    return reporting(async () => {
+        const [from, to] = parsed.positional;
+        const contains = text(parsed, "path");
+        const context = Number(text(parsed, "context") ?? 3);
+        const changes = await (0, history_js_1.diff)(repository, {
+            from,
+            to,
+            only: contains ? (file) => file.includes(contains) : undefined,
+            context: Number.isFinite(context) && context >= 0 ? context : 3,
+        });
+        if (!changes.length) {
+            console.log(to ? "Those two saves hold the same files." : "Nothing has changed since the last save.");
+            return 0;
+        }
+        const mark = { added: green("+"), modified: accent("~"), deleted: red("-") };
+        for (const change of changes) {
+            console.log(`${mark[change.kind]} ${bold(change.path)}`);
+            if (has(parsed, "name-only"))
+                continue;
+            if (change.executableChanged)
+                console.log(dim("    execute permission changed"));
+            if (change.summary) {
+                console.log(dim(`    ${change.summary}`));
+                continue;
+            }
+            for (const chunk of change.chunks ?? []) {
+                if (chunk.kind === "gap") {
+                    console.log(dim(`    ... ${chunk.skipped} unchanged`));
+                    continue;
+                }
+                for (const line of chunk.lines) {
+                    const at = String(line.candidateLine ?? line.targetLine ?? "").padStart(5);
+                    if (line.side === "same")
+                        console.log(dim(`${at}   ${line.text}`));
+                    else if (line.side === "candidate")
+                        console.log(`${dim(at)} ${green("+")} ${green(line.text)}`);
+                    else
+                        console.log(`${dim(at)} ${red("-")} ${red(line.text)}`);
+                }
+            }
+        }
+        return 0;
+    });
+}
+/* ---- restore --------------------------------------------------------- */
+async function commandRestore(parsed) {
+    return reporting(async () => {
+        const repository = await repository_js_1.Repository.open(node_process_1.default.cwd());
+        const from = text(parsed, "from");
+        const result = await (0, history_js_1.restore)(repository, {
+            from,
+            only: (0, history_js_1.pathFilter)(repository, parsed.positional),
+            force: has(parsed, "force", "f"),
+        });
+        const touched = result.written.length + result.removed.length;
+        if (!touched) {
+            console.log(`Already matches ${accent(short(result.save.id))}; nothing to put back.`);
+            return 0;
+        }
+        console.log(`Put back ${plural(touched, "file")} from ${accent(short(result.save.id))}: ` +
+            `${result.save.message.split("\n")[0]}`);
+        for (const file of result.written.slice(0, 20))
+            console.log(`  ${green("restored")} ${file}`);
+        for (const file of result.removed.slice(0, 20))
+            console.log(`  ${red("removed ")} ${file}`);
+        if (touched > 40)
+            console.log(dim(`  … and more`));
+        console.log(dim("Your line has not moved. Save to record the folder as it is now."));
+        return 0;
+    });
+}
+/* ---- switch ---------------------------------------------------------- */
+async function localSwitch(parsed, repository) {
+    return reporting(async () => {
+        const line = parsed.positional[0];
+        if (!line) {
+            const current = await repository.currentLine();
+            for (const one of await repository.lines()) {
+                console.log(`${one.name === current ? accent("*") : " "} ${one.name}  ${dim(short(one.tip))}`);
+            }
+            if (!(await repository.lineExists(current))) {
+                console.log(`${accent("*")} ${current}  ${dim("nothing saved yet")}`);
+            }
+            return 0;
+        }
+        const result = await (0, history_js_1.switchLine)(repository, line, {
+            create: has(parsed, "c", "create", "new", "n"),
+            force: has(parsed, "force", "f"),
+        });
+        if (result.created) {
+            console.log(`Started ${accent(result.line)}` +
+                (result.save ? ` from ${accent(short(result.save.id))}.` : ".") +
+                dim(" No files changed."));
+            return 0;
+        }
+        const touched = result.written.length + result.removed.length;
+        console.log(`On ${accent(result.line)} now` +
+            (touched ? `, ${plural(touched, "file")} changed.` : ", and no files needed changing."));
+        return 0;
+    });
+}
+/* ---- push and pull ---------------------------------------------------- */
+/**
+ * Keep the folder's CodeRook link in step with what a push or pull made, so
+ * `cbx submit` and `cbx get` in the same folder start from the same place.
+ */
+async function recordLink(repository, line, repositoryId, head, manifest) {
+    const link = await (0, config_js_1.readLink)(repository.root);
+    const slug = (await (0, api_js_1.projectById)(repositoryId).catch(() => null))?.slug ??
+        link?.slug ??
+        node_path_1.default.basename(repository.root);
+    await (0, config_js_1.writeLink)(repository.root, {
+        ...(link ?? {}),
+        repositoryId,
+        slug,
+        sequence: head.sequence,
+        track: line,
+        versionId: head.versionId,
+        baseVersionId: head.versionId,
+        observedHeadVersionId: head.versionId,
+        manifest,
+        local: manifest,
+    });
+}
+async function localPush(parsed, repository) {
+    return reporting(async () => {
+        const link = await (0, config_js_1.readLink)(repository.root);
+        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,
+            allowSecrets: has(parsed, "allow-secrets"),
+            acknowledged: has(parsed, "yes", "y"),
+            report: (event) => {
+                if (event.kind === "save" && interactive) {
+                    node_process_1.default.stdout.write(`\r${dim(`Sending ${event.index + 1} of ${event.total}: ${event.save.message.split("\n")[0].slice(0, 50)}`)}   `);
+                }
+                if (event.kind === "pushed" || event.kind === "unchanged") {
+                    if (interactive)
+                        node_process_1.default.stdout.write(`\r${" ".repeat(80)}\r`);
+                    console.log(`  ${accent(short(event.save.id))}  ` +
+                        (event.kind === "pushed" ? green(`v${event.sequence}`) : dim("already there")) +
+                        `  ${event.save.message.split("\n")[0]}`);
+                }
+            },
+        });
+        if (!result.pushed.length) {
+            console.log(`Everything on ${accent(result.line)} is already on CodeRook.`);
+            return 0;
+        }
+        const last = result.pushed[result.pushed.length - 1];
+        console.log(`Pushed ${plural(result.pushed.length, "save")} to CodeRook on ${accent(result.line)}; ` +
+            `it is at ${accent(`v${last.sequence}`)} now.`);
+        if (result.repositoryId && result.head) {
+            await recordLink(repository, result.line, result.repositoryId, result.head, result.head.manifest);
+        }
+        return 0;
+    });
+}
+async function localPull(parsed, repository) {
+    return reporting(async () => {
+        let repositoryId = (await (0, remote_js_1.readRemote)(repository)).repositoryId;
+        const named = parsed.positional[0];
+        if (named) {
+            const project = await (0, project_commands_js_1.resolveProject)(named);
+            if (!project)
+                return 1;
+            repositoryId = project.id;
+        }
+        repositoryId ??= (await (0, config_js_1.readLink)(repository.root))?.repositoryId ?? null;
+        const interactive = node_process_1.default.stdout.isTTY;
+        const result = await (0, remote_js_1.pull)(repository, {
+            credentials: config_js_1.credentials,
+            repositoryId,
+            force: has(parsed, "force", "f"),
+            report: (event) => {
+                if (!interactive)
+                    return;
+                if (event.kind === "version") {
+                    node_process_1.default.stdout.write(`\r${dim(`Fetching v${event.version.sequence} (${event.index + 1} of ${event.total})`)}${" ".repeat(20)}`);
+                }
+            },
+        });
+        if (interactive)
+            node_process_1.default.stdout.write(`\r${" ".repeat(80)}\r`);
+        for (const save of result.imported)
+            console.log(`  ${describeSave(save)}`);
+        if (result.merged?.conflicts) {
+            console.log(`CodeRook's ${accent(result.line)} and this history had both moved on, and merging them left ` +
+                red(plural(result.merged.conflicts.length, "conflict")) + ":");
+            for (const conflict of result.merged.conflicts)
+                console.log(`  ${red("conflict")} ${conflict.path}`);
+            console.log(dim("Fix them, then cbx save and cbx push. cbx status lists them; cbx merge --cancel calls it off."));
+            return 1;
+        }
+        if (result.merged?.save) {
+            const touched = result.written.length + result.removed.length;
+            console.log(`Merged ${plural(result.imported.length, "save")} from CodeRook's ${accent(result.line)} with this history's own` +
+                (touched ? `; ${plural(touched, "file")} changed.` : ".") +
+                ` Push to send the merge.`);
+            return 0;
+        }
+        if (!result.moved) {
+            console.log(result.imported.length
+                ? `Fetched ${plural(result.imported.length, "save")}.`
+                : `Already up to date with CodeRook's ${accent(result.line)}.`);
+            return 0;
+        }
+        const touched = result.written.length + result.removed.length;
+        console.log(`Pulled ${plural(result.imported.length, "save")} on ${accent(result.line)}` +
+            (touched ? `; ${plural(touched, "file")} changed.` : "."));
+        const pulledFrom = (await (0, remote_js_1.readRemote)(repository)).repositoryId;
+        const tip = await repository.head();
+        if (pulledFrom && result.head && tip) {
+            const tree = await repository.readTree((await repository.readSave(tip)).tree);
+            const manifest = Object.fromEntries(tree.files.map((file) => [file.path, file.sha256]));
+            await recordLink(repository, result.line, pulledFrom, result.head, manifest);
+        }
+        return 0;
+    });
+}
+/* ---- merge ------------------------------------------------------------ */
+async function localMerge(parsed, repository) {
+    return reporting(async () => {
+        if (has(parsed, "cancel", "abort")) {
+            const put = await (0, history_js_1.cancelMerge)(repository);
+            console.log(`Merge called off; ${plural(put.length, "file")} put back as the last save had them.`);
+            return 0;
+        }
+        const pathText = text(parsed, "path");
+        const only = pathText ? (0, history_js_1.pathFilter)(repository, [pathText]) : undefined;
+        for (const side of ["mine", "theirs"]) {
+            if (!has(parsed, side))
+                continue;
+            const settled = await (0, history_js_1.resolveConflicts)(repository, side, only);
+            console.log(`Took ${side === "mine" ? "this line's" : "the other"} side of ${plural(settled.length, "file")}:`);
+            for (const file of settled)
+                console.log(`  ${file}`);
+            console.log(dim("Save when the rest are settled."));
+            return 0;
+        }
+        const other = parsed.positional[0];
+        if (!other) {
+            console.error(red("Merge what? Name a line or a save: cbx merge feature"));
+            return 1;
+        }
+        const outcome = await (0, history_js_1.merge)(repository, other, { message: text(parsed, "m", "message") });
+        const touched = (outcome.kind === "up-to-date" ? 0 : outcome.written.length + outcome.removed.length);
+        if (outcome.kind === "up-to-date") {
+            console.log(`${other} is already part of this line.`);
+        }
+        else if (outcome.kind === "fast-forward") {
+            console.log(`Moved to ${accent(short(outcome.save.id))}; ${plural(touched, "file")} changed. Nothing needed merging.`);
+        }
+        else if (outcome.kind === "merged") {
+            console.log(`Merged ${accent(other)} as ${accent(short(outcome.save.id))}; ${plural(touched, "file")} changed.`);
+        }
+        else {
+            console.log(`Merged what could be merged; ${red(plural(outcome.state.conflicts.length, "conflict"))} left:`);
+            for (const conflict of outcome.state.conflicts)
+                console.log(`  ${red("conflict")} ${conflict.path}`);
+            console.log(dim("Fix them, then cbx save. Or take a side: cbx merge --theirs [--path file]. Or cbx merge --cancel."));
+            return 1;
+        }
+        return 0;
+    });
+}

package/dist/cli/src/mcp.js

@@ -27,8 +27,8 @@ 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 download_js_1 = require("../../desktop-app/src/main/download.js");
-const worktree_js_1 = require("../../desktop-app/src/main/worktree.js");
+const download_js_1 = require("../../cbx/src/core/download.js");
+const worktree_js_1 = require("../../cbx/src/core/worktree.js");
 const api_js_1 = require("./api.js");
 const config_js_1 = require("./config.js");
 /** What the protocol calls itself. Both clients accept this revision. */