huddle-cli 0.1.3 → 0.1.5

package/dist/ui/undo.js

@@ -0,0 +1,131 @@
+// `huddle undo`: take back what a run merged. It adds one commit that reverts
+// the run's commits (history stays; nothing is force-pushed), so an undo can
+// itself be undone with git revert.
+//
+//   huddle undo            the last run (asks first; --yes doesn't)
+//   huddle undo --run 3    that run (numbers from `huddle runs`)
+import fs from "node:fs";
+import readline from "node:readline";
+import { spawnSync } from "node:child_process";
+import { C } from "./term.js";
+import { pickRun, splitRuns } from "./story.js";
+const git = (root, args) => {
+    const r = spawnSync("git", args, { cwd: root, encoding: "utf8" });
+    return { ok: r.status === 0, out: (r.stdout ?? "").trim(), err: (r.stderr ?? "").trim() };
+};
+/** What undoing run `which` would revert, or why it can't. */
+export function undoPlan(root, events, which) {
+    const runs = splitRuns(events);
+    const run = pickRun(runs, which);
+    if (!run)
+        return { ok: false, why: runs.length ? `no run ${which} (see huddle runs)` : "no runs here yet" };
+    const base = { index: run.index, goal: run.goal, id: run.id };
+    // An undo is recorded when it happens, so it lands in whichever run is the
+    // latest by then: look in every run for one that names this run.
+    const undone = runs.some((r) => r.events.some((e) => e.type === "git.undone" && (e.p.id ? e.p.id === run.id : Number(e.p.run) === run.index)));
+    if (undone)
+        return { ...base, ok: false, why: `run ${run.index} is already undone` };
+    const g = run.events.filter((e) => e.type === "git.range").at(-1);
+    if (!g)
+        return { ...base, ok: false, why: `run ${run.index} has no record of its commits (it ran before Huddle 0.1.4, or didn't finish)` };
+    const start = String(g.p.start ?? "");
+    const end = String(g.p.end ?? "");
+    if (!start || !end || start === end)
+        return { ...base, ok: false, why: `run ${run.index} didn't merge anything` };
+    if (!git(root, ["merge-base", "--is-ancestor", end, "HEAD"]).ok)
+        return { ...base, ok: false, why: `run ${run.index}'s commits aren't on this branch (${git(root, ["symbolic-ref", "--short", "HEAD"]).out || "detached HEAD"})` };
+    const commits = git(root, ["log", "--format=%h %s", `${start}..${end}`]).out.split("\n").filter(Boolean);
+    return { ...base, ok: true, start, end, commits };
+}
+/** The run's goal as one short line, for the revert commit and the screen. */
+export const undoTitle = (plan) => String(plan.goal ?? "").split("\n")[0].slice(0, 80);
+/**
+ * Carries out a plan from undoPlan: the revert commit, then the git.undone
+ * event that marks the run undone. `huddle undo` and the dashboard both go
+ * through here, so an undo is recorded the same way wherever you clicked it.
+ */
+export function undoRun(root, db, plan) {
+    if (!plan.ok)
+        return { ok: false, why: plan.why };
+    const goal = undoTitle(plan);
+    const r = revertRange(root, plan.start, plan.end, `huddle: undo run ${plan.index} (${goal})\n\nReverts ${plan.start.slice(0, 7)}..${plan.end.slice(0, 7)}.`);
+    if (!r.ok)
+        return { ok: false, why: r.why };
+    db.publish("git.undone", { payload: { run: plan.index, ...(plan.id ? { id: plan.id } : {}), commit: r.commit } });
+    const up = git(root, ["rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{u}"]);
+    const pushed = up.ok && git(root, ["merge-base", "--is-ancestor", plan.end, up.out]).ok;
+    return { ok: true, commit: r.commit, ...(pushed ? { pushedTo: up.out } : {}) };
+}
+/** Reverts start..end as one commit. A conflict (later work built on it) leaves the tree as it was. */
+export function revertRange(root, start, end, message) {
+    const dirty = git(root, ["status", "--porcelain", "--untracked-files=no"]).out;
+    if (dirty)
+        return { ok: false, why: "you have uncommitted changes — commit or stash them first" };
+    const r = git(root, ["revert", "--no-edit", "--no-commit", `${start}..${end}`]);
+    if (!r.ok) {
+        git(root, ["revert", "--abort"]);
+        git(root, ["reset", "--hard", "-q", "HEAD"]);
+        return { ok: false, why: "later commits build on this run's work, so it can't be taken back cleanly — revert by hand: git revert " + `${start.slice(0, 7)}..${end.slice(0, 7)}` };
+    }
+    if (!git(root, ["status", "--porcelain", "--untracked-files=no"]).out) {
+        git(root, ["revert", "--quit"]);
+        return { ok: false, why: "nothing to undo: the run's changes are already gone from this branch" };
+    }
+    const c = git(root, ["commit", "-q", "--no-verify", "-m", message]);
+    if (!c.ok) {
+        git(root, ["revert", "--abort"]);
+        return { ok: false, why: c.err.split("\n")[0] || "git commit failed" };
+    }
+    git(root, ["revert", "--quit"]);
+    return { ok: true, commit: git(root, ["rev-parse", "--short", "HEAD"]).out };
+}
+async function confirm(q) {
+    if (!process.stdin.isTTY)
+        return false;
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    const a = await new Promise((r) => rl.question(q, r));
+    rl.close();
+    return /^y(es)?$/i.test(a.trim());
+}
+export async function runUndo(args) {
+    const { dbPath, repoRoot } = await import("./app.js");
+    if (!fs.existsSync(dbPath())) {
+        console.log(C.faint("  no runs here yet — nothing to undo."));
+        return 0;
+    }
+    const i = args.indexOf("--run");
+    const which = i >= 0 ? args[i + 1] : args.find((a) => /^\d+$/.test(a));
+    const { RoomDB } = await import("../room/db.js");
+    const db = new RoomDB(dbPath());
+    try {
+        const root = repoRoot();
+        const plan = undoPlan(root, db.allEvents(), which);
+        if (!plan.ok) {
+            console.log(C.red("✗ ") + plan.why);
+            return 1;
+        }
+        console.log(`Undo run ${plan.index}: ${C.bold(undoTitle(plan))}`);
+        console.log(C.faint(`  it reverts ${plan.commits.length} commit(s), as one new commit:`));
+        for (const c of plan.commits.slice(0, 12))
+            console.log(C.faint(`    ${c}`));
+        if (plan.commits.length > 12)
+            console.log(C.faint(`    … and ${plan.commits.length - 12} more`));
+        if (!args.includes("--yes") && !args.includes("-y") && !(await confirm("  Undo it? [y/N] "))) {
+            console.log(C.faint(process.stdin.isTTY ? "  left as it is." : "  not a terminal: add --yes to undo."));
+            return process.stdin.isTTY ? 0 : 1;
+        }
+        const r = undoRun(root, db, plan);
+        if (!r.ok) {
+            console.log(C.red("✗ ") + r.why);
+            return 1;
+        }
+        console.log(`${C.green("✓")} undone in ${r.commit}. ${C.faint(`Changed your mind? git revert ${r.commit}`)}`);
+        if (r.pushedTo)
+            console.log(C.faint(`  the run was already pushed to ${r.pushedTo}: git push sends the undo there too`));
+        return 0;
+    }
+    finally {
+        db.close();
+    }
+}
+//# sourceMappingURL=undo.js.map

package/dist/update.js

@@ -0,0 +1,84 @@
+// `huddle update`: get the newest Huddle from npm. Found live (0.1.3): the user
+// typed `huddle --update`, the way other CLIs work, and got "unknown command".
+import { fileURLToPath } from "node:url";
+import { packageInfo } from "./preflight.js";
+import { spawnToolSync } from "./platform.js";
+import { C } from "./ui/term.js";
+/** -1, 0 or 1, comparing x.y.z (a pre-release tag sorts before its release). */
+export function compareVersions(a, b) {
+    const parse = (v) => {
+        const [core, pre] = v.trim().replace(/^v/, "").split("-", 2);
+        return { nums: core.split(".").map((n) => Number(n) || 0), pre: pre ?? "" };
+    };
+    const x = parse(a);
+    const y = parse(b);
+    for (let i = 0; i < 3; i++) {
+        const d = (x.nums[i] ?? 0) - (y.nums[i] ?? 0);
+        if (d)
+            return Math.sign(d);
+    }
+    if (x.pre === y.pre)
+        return 0;
+    if (!x.pre)
+        return 1;
+    if (!y.pre)
+        return -1;
+    return x.pre < y.pre ? -1 : 1;
+}
+/**
+ * What `huddle update` should do. Only an npm install (a path through
+ * node_modules/huddle-cli) is replaced with npm; a source checkout is told how
+ * to update itself instead of getting a second, global copy.
+ */
+export function updatePlan(current, latest, cliPath) {
+    if (!latest)
+        return { kind: "offline" };
+    const c = compareVersions(current, latest);
+    if (c === 0)
+        return { kind: "latest", current };
+    if (c > 0)
+        return { kind: "ahead", current, latest };
+    if (!/[\\/]node_modules[\\/]huddle-cli[\\/]/.test(cliPath)) {
+        return { kind: "source", current, latest, dir: cliPath.replace(/[\\/]dist[\\/].*$/, "") };
+    }
+    return { kind: "install", current, latest };
+}
+/** The newest huddle-cli on npm, or null when npm can't be reached. */
+export function latestOnNpm() {
+    const r = spawnToolSync(["npm", "view", "huddle-cli", "version", "--prefer-online"], { encoding: "utf8", timeout: 30_000 });
+    const v = r.status === 0 ? r.stdout.trim().split(/\s+/).pop() ?? "" : "";
+    return /^\d+\.\d+\.\d+/.test(v) ? v : null;
+}
+export function runUpdate() {
+    const current = packageInfo().version;
+    console.log(C.faint(`huddle ${current} · checking npm…`));
+    const plan = updatePlan(current, latestOnNpm(), fileURLToPath(import.meta.url));
+    switch (plan.kind) {
+        case "offline":
+            console.log(C.red("✗ couldn't reach npm.") + " Check your connection, or run: npm install -g huddle-cli@latest");
+            return 1;
+        case "latest":
+            console.log(C.green("✓") + ` huddle ${plan.current} is the newest version.`);
+            return 0;
+        case "ahead":
+            console.log(C.green("✓") + ` huddle ${plan.current} is newer than npm's ${plan.latest} (a preview build). Nothing to do.`);
+            return 0;
+        case "source":
+            console.log(`huddle ${plan.latest} is out; this huddle runs from a source checkout (${plan.dir}).`);
+            console.log(C.faint("  update it there: git pull && npm install && npm run build"));
+            return 0;
+        case "install": {
+            console.log(`updating huddle ${plan.current} → ${C.violet(plan.latest)}`);
+            const r = spawnToolSync(["npm", "install", "-g", `huddle-cli@${plan.latest}`], { stdio: "inherit" });
+            if (r.status !== 0) {
+                console.log(C.red("✗ npm couldn't install it.") + ` Try it yourself: npm install -g huddle-cli@${plan.latest}`);
+                if (process.platform !== "win32")
+                    console.log(C.faint("  a permissions error means npm's global folder needs sudo; nvm avoids that"));
+                return 1;
+            }
+            console.log(C.green("✓") + ` huddle ${plan.latest} installed.` + C.faint(" Open a new terminal (or run hash -r) if `huddle --version` still shows the old one."));
+            return 0;
+        }
+    }
+}
+//# sourceMappingURL=update.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "huddle-cli",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "description": "The multiplayer layer for AI coding agents. One command. Every agent. One repo. Zero collisions.",
   "type": "module",
   "bin": {
@@ -51,6 +51,7 @@
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.0.0",
     "nanoid": "^5.0.0",
+    "qrcode-terminal": "0.12.0",
     "ws": "^8.18.0"
   },
   "optionalDependencies": {
@@ -59,6 +60,7 @@
   "devDependencies": {
     "@types/node": "^22.0.0",
     "@types/ws": "^8.5.0",
+    "jsqr": "1.4.0",
     "puppeteer": "^24.43.1",
     "typescript": "^5.6.0"
   }