huddle-cli 0.0.0-stage → 0.1.0

package/dist/ui/catalog.js

@@ -0,0 +1,75 @@
+// `huddle agents --all`: every connector Huddle knows — built in, or declared
+// in agents.json — with whether it's on this machine and how to get it.
+// `huddle agents install <id>` installs one, always after asking.
+import readline from "node:readline/promises";
+import { spawnSync } from "node:child_process";
+import { ADAPTERS, AGENTS_FILE_ERRORS, BUILTIN_ADAPTERS, probe } from "../adapters/index.js";
+import { agentsFiles } from "../adapters/custom.js";
+import { C, dot, pad } from "./term.js";
+function all() {
+    const seen = new Map();
+    for (const a of [...BUILTIN_ADAPTERS, ...ADAPTERS])
+        seen.set(a.id, a); // the roster's version wins (agents.json overrides)
+    return [...seen.values()];
+}
+const tilde = (p) => p.replace(process.env.HOME ?? "\0", "~");
+export function printCatalog() {
+    console.log(`\n${C.bold("Connectors")} ${C.faint("· any CLI that runs headless and speaks MCP can join")}\n`);
+    for (const a of all()) {
+        const r = probe(a);
+        const state = r.state === "ready" ? C.green("ready") : r.state === "not_authed" ? C.yellow("not signed in") : C.faint("not installed");
+        const from = a.source ? C.faint(` · ${tilde(a.source)}`) : "";
+        console.log(`  ${dot(a.id)} ${pad(C.bold(a.id), 13)} ${pad(C.faint(a.vendor), 13)} ${pad(state, 14)}${from}`);
+        if (r.state === "not_installed" && a.install.cmd)
+            console.log(`      ${C.faint("$ " + a.install.cmd)}`);
+        else if (r.state === "not_authed")
+            console.log(`      ${C.faint(r.detail)}`);
+    }
+    for (const e of AGENTS_FILE_ERRORS)
+        console.log(`  ${C.yellow("!")} ${C.faint(e)}`);
+    const f = agentsFiles(null);
+    console.log(`\n  ${C.faint("install one:")} huddle agents install <id>`);
+    console.log(`  ${C.faint("add your own:")} ${tilde(f.user)} ${C.faint("(see docs/ADAPTERS.md)")}\n`);
+}
+/** Install a connector's CLI (and offer its sign-in) — only after a yes. */
+export async function installConnector(id) {
+    const a = all().find((x) => x.id === id);
+    if (!a) {
+        console.log(C.red(`✗ no connector called ${id}.`) + " See `huddle agents --all`.");
+        return false;
+    }
+    if (!a.install.cmd) {
+        console.log(`${a.id} has no install command — install ${a.bin} the way its docs say${a.homepage ? `: ${a.homepage}` : "."}`);
+        return false;
+    }
+    if (!process.stdin.isTTY) {
+        console.log(`To install ${a.id}, run:\n  ${a.install.cmd}`);
+        return false;
+    }
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    try {
+        console.log(`\n  ${dot(a.id)} ${C.bold(a.id)}  ${C.faint("$ " + a.install.cmd)}`);
+        const ans = (await rl.question(`Install ${a.id}? ${C.faint("[Y/n]")} `)).trim().toLowerCase();
+        if (ans && !ans.startsWith("y"))
+            return false;
+        rl.pause();
+        const ok = spawnSync("sh", ["-c", a.install.cmd], { stdio: "inherit" }).status === 0;
+        rl.resume();
+        console.log(ok ? C.green(`✓ ${a.id} installed`) : C.red(`✗ ${a.id} install failed — see output above`));
+        if (ok && a.install.login) {
+            const go = (await rl.question(`Sign in to ${a.id} now? ${C.faint("[Y/n]")} `)).trim().toLowerCase();
+            if (!go || go.startsWith("y")) {
+                if (a.install.loginNote)
+                    console.log(C.faint(`  ${a.install.loginNote}`));
+                rl.pause();
+                spawnSync(a.install.login[0], a.install.login.slice(1), { stdio: "inherit" });
+                rl.resume();
+            }
+        }
+        return ok;
+    }
+    finally {
+        rl.close();
+    }
+}
+//# sourceMappingURL=catalog.js.map

package/dist/ui/dashboard.js

@@ -0,0 +1,192 @@
+// The live view — the full-screen dashboard from the launch film.
+//
+//   ⬢ huddle   1 agents  2 plan  3 board        room: <goal>  ● live  ⏱ 1m12s
+//   ┌ ● claude  anthropic ─ working 40s · 31k ┐┌ ● codex  openai ─ idle ───────┐
+//   │ ▸ Add greet(name) with tests            ││ ✓ merged Add farewell…         │
+//   │   plans: CommonJS greet.js …            ││                                │
+//   └─────────────────────────────────────────┘└────────────────────────────────┘
+//   ◆ harsh/codex → room  what shape is the Order type?
+//   1 2 3 switch · q back to the prompt · ctrl-c stop agents
+//
+// It only reads: the Room's board and memory, the run's live stats, and the
+// activity feed. Pressing q hands the terminal back to the prompt.
+import { C, dot, pad, truncate, width, AGENT_COLOR } from "./term.js";
+import { fmtDuration, fmtTokens } from "../adapters/usage.js";
+const hexColor = (id) => C.hex(AGENT_COLOR[id.split("/").pop().split("#")[0]] ?? "#8A857C");
+export class Dashboard {
+    src;
+    tab = "agents";
+    open = false;
+    timer;
+    feed = [];
+    onKey;
+    constructor(src) {
+        this.src = src;
+    }
+    isOpen() {
+        return this.open;
+    }
+    /** Keep a rolling log whether or not the view is on screen. */
+    push(a) {
+        this.feed.push({ ...a, ts: Date.now() });
+        if (this.feed.length > 400)
+            this.feed.splice(0, this.feed.length - 400);
+        if (this.open)
+            this.render();
+    }
+    show(tab, onClose) {
+        if (!process.stdout.isTTY)
+            return;
+        if (tab)
+            this.tab = tab;
+        if (this.open)
+            return this.render();
+        this.open = true;
+        process.stdout.write("\x1b[?1049h\x1b[?25l"); // alternate screen, hide cursor
+        this.onKey = (s, key) => {
+            if (!this.open)
+                return;
+            const k = key?.name ?? s;
+            if (s === "1")
+                this.tab = "agents";
+            else if (s === "2")
+                this.tab = "plan";
+            else if (s === "3")
+                this.tab = "board";
+            else if (k === "tab")
+                this.tab = this.tab === "agents" ? "plan" : this.tab === "plan" ? "board" : "agents";
+            else if (s === "q" || k === "escape" || (key?.ctrl && key.name === "t")) {
+                this.hide();
+                onClose?.();
+                return;
+            }
+            this.render();
+        };
+        process.stdin.on("keypress", this.onKey);
+        process.stdout.on("resize", this.renderBound);
+        this.timer = setInterval(() => this.render(), 500);
+        this.render();
+    }
+    hide() {
+        if (!this.open)
+            return;
+        this.open = false;
+        if (this.timer)
+            clearInterval(this.timer);
+        if (this.onKey)
+            process.stdin.off("keypress", this.onKey);
+        process.stdout.off("resize", this.renderBound);
+        process.stdout.write("\x1b[?25h\x1b[?1049l"); // back to the normal screen
+    }
+    renderBound = () => this.render();
+    render() {
+        if (!this.open)
+            return;
+        const W = process.stdout.columns || 100;
+        const H = process.stdout.rows || 30;
+        const db = this.src.db();
+        const stats = this.src.stats();
+        const goal = db?.currentSession()?.goal ?? "no goal yet — press q and type one";
+        const tabs = ["agents", "plan", "board"]
+            .map((t, i) => (t === this.tab ? C.bold(C.violet(` ${i + 1} ${t} `)) : C.faint(` ${i + 1} ${t} `)))
+            .join(" ");
+        const right = `${C.faint("room:")} ${truncate(goal, Math.max(10, W - 70))}  ` +
+            (stats ? `${C.green("● live")}  ${C.faint("⏱")} ${fmtDuration(Date.now() - stats.startedAt)}` : C.faint("○ idle"));
+        const bar = ` ${C.violet("⬢")} ${C.bold("huddle")}  ${tabs}`;
+        const top = bar + " ".repeat(Math.max(1, W - width(bar) - width(right) - 1)) + right;
+        const bodyH = H - 4;
+        const body = this.tab === "agents" ? this.agents(W, bodyH, stats) : this.tab === "plan" ? this.plan(W, bodyH, db) : this.board(W, bodyH, db);
+        const lastRoom = [...this.feed].reverse().find((a) => !a.agent);
+        const strip = lastRoom ? ` ${truncate(lastRoom.text, W - 2)}` : C.faint(" the room is quiet");
+        const hint = C.faint(` ${this.src.hint ?? "1 2 3 switch · q back to the prompt · ctrl-c stop agents"}   ${this.src.modeChip()}`);
+        const lines = [truncate(top, W), C.faint("─".repeat(W)), ...body.slice(0, bodyH), strip, hint];
+        while (lines.length < H)
+            lines.splice(lines.length - 2, 0, "");
+        process.stdout.write("\x1b[H" + lines.slice(0, H).map((l) => "\x1b[2K" + truncate(l, W)).join("\n"));
+    }
+    /** Tab 1: a pane per agent — what each one is doing right now. */
+    agents(W, H, stats) {
+        const ids = stats ? [...stats.agents.keys()] : [...new Set(this.feed.filter((a) => a.agent).map((a) => a.agent))];
+        if (!ids.length)
+            return [C.faint("  no agents working — give Huddle a goal")];
+        const cols = W >= 110 && ids.length > 1 ? 2 : 1;
+        const rows = Math.ceil(ids.length / cols);
+        const paneW = Math.floor(W / cols);
+        const paneH = Math.max(4, Math.floor(H / rows));
+        const out = [];
+        for (let r = 0; r < rows; r++) {
+            const panes = ids.slice(r * cols, r * cols + cols).map((id) => this.pane(id, paneW, paneH, stats?.agents.get(id)));
+            for (let i = 0; i < paneH; i++)
+                out.push(panes.map((p) => p[i] ?? " ".repeat(paneW)).join(""));
+        }
+        return out;
+    }
+    pane(id, w, h, a) {
+        const color = hexColor(id);
+        const status = a?.busySince
+            ? `${C.violet("working")} ${fmtDuration(Date.now() - a.busySince)}${a.liveTokens > 0 ? " · " + fmtTokens(a.liveTokens) + " tok" : ""}`
+            : a && (a.tasks || a.reviews)
+                ? C.green(`done · ${a.tasks} task${a.tasks === 1 ? "" : "s"}${a.reviews ? ` + ${a.reviews} review` : ""}`)
+                : C.faint("idle");
+        const title = ` ${dot(id)} ${C.bold(id)}  ${status} `;
+        const inner = w - 2;
+        const topLine = color("╭─") + title + color("─".repeat(Math.max(0, inner - 1 - width(title))) + "╮");
+        const lines = this.feed.filter((x) => x.agent === id).slice(-(h - 2));
+        const body = Array.from({ length: h - 2 }, (_, i) => {
+            const l = lines[i] ? " " + truncate(lines[i].text, inner - 2) : "";
+            return color("│") + pad(l, inner) + color("│");
+        });
+        return [topLine, ...body, color("╰" + "─".repeat(inner) + "╯")];
+    }
+    /** Tab 2: the plan on the left, the room talking on the right. */
+    plan(W, H, db) {
+        const leftW = Math.floor(W * 0.55);
+        const left = [C.violet(" PLAN")];
+        const tasks = db?.listTasks() ?? [];
+        const idx = new Map(tasks.map((t, i) => [t.id, i + 1]));
+        tasks.forEach((t, i) => {
+            const deps = JSON.parse(t.depends_on || "[]");
+            const after = deps.length ? C.faint(` after ${deps.map((d) => idx.get(d)).join(",")}`) : "";
+            const who = t.claimed_by ? ` ${dot(t.claimed_by)} ${C.faint(t.claimed_by)}` : "";
+            left.push(` ${C.faint(String(i + 1) + ".")} ${t.title}${after}${who}`);
+            left.push(C.faint(`    ${t.status}`));
+        });
+        if (!tasks.length)
+            left.push(C.faint("  no plan yet"));
+        const right = [C.violet(" ROOM") + C.faint(" · agents & people talking")];
+        for (const a of this.feed.filter((x) => !x.agent).slice(-(H - 1)))
+            right.push(" " + a.text);
+        return columns(left, right, leftW, W, H);
+    }
+    /** Tab 3: progress on the left, shared memory on the right. */
+    board(W, H, db) {
+        const leftW = Math.floor(W * 0.55);
+        const left = [C.violet(" BOARD") + C.faint(" · live progress")];
+        for (const t of db?.listTasks() ?? []) {
+            const bw = 14;
+            const filled = Math.round((t.progress_pct / 100) * bw);
+            const barS = t.status === "merged" ? C.green("█".repeat(bw)) : C.violet("█".repeat(filled)) + C.faint("░".repeat(bw - filled));
+            const st = t.status === "merged" ? C.green("✓") : t.status === "failed" ? C.red("✗") : t.status === "needs_you" ? C.yellow("!") : t.claimed_by ? C.violet("▸") : C.faint("○");
+            left.push(` ${st} ${barS} ${String(t.progress_pct).padStart(3)}%  ${t.title}`);
+            if (t.claimed_by)
+                left.push(C.faint(`                        ${t.claimed_by}`));
+        }
+        const right = [C.violet(" SHARED MEMORY") + C.faint(" · everyone reads & writes")];
+        for (const m of (db?.recall() ?? []).slice(0, H - 1)) {
+            right.push(` ${C.faint("•")} ${m.body}`);
+            if (m.why)
+                right.push(C.faint(`   why: ${m.why}`));
+        }
+        return columns(left, right, leftW, W, H);
+    }
+}
+function columns(left, right, leftW, W, H) {
+    const out = [];
+    for (let i = 0; i < H; i++) {
+        const l = truncate(left[i] ?? "", leftW - 1);
+        const r = truncate(right[i] ?? "", W - leftW - 2);
+        out.push(pad(l, leftW - 1) + C.faint("│") + " " + r);
+    }
+    return out;
+}
+//# sourceMappingURL=dashboard.js.map

package/dist/ui/doctor.js

@@ -0,0 +1,54 @@
+// `huddle doctor`: is this machine ready? Huddle itself (Node, git, the room
+// database), then your agents — and, when something's missing, the exact next
+// command. Read-only: it never installs or signs in; `huddle` offers that (and
+// asks first). Exit code 1 when Huddle can't run a goal here yet.
+import { spawnSync } from "node:child_process";
+import { LEGACY } from "../adapters/index.js";
+import { packageInfo } from "../preflight.js";
+import { sqliteStatus } from "../room/sqlite.js";
+import { connectAgents } from "./app.js";
+import { C, dot } from "./term.js";
+export async function runDoctor() {
+    let blocked = false;
+    const gitV = spawnSync("git", ["--version"], { encoding: "utf8" });
+    const gitNum = gitV.status === 0 ? (gitV.stdout.match(/\d+\.\d+(\.\d+)?/)?.[0] ?? "") : null;
+    const db = sqliteStatus();
+    const parts = [
+        `${C.violet("huddle")} ${packageInfo().version}`,
+        `node ${process.versions.node}`,
+        gitNum === null ? C.red("git missing") : `git ${gitNum}`.trim(),
+        db.ok ? `room db: ${db.driver}` : C.red("room db: unavailable"),
+    ];
+    console.log("\n  " + parts.join(C.faint("  ·  ")));
+    if (gitNum === null) {
+        blocked = true;
+        console.log(C.red("\n✗ git isn't installed.") + " Huddle gives every agent its own git worktree.");
+        console.log(C.faint("  macOS: xcode-select --install  ·  Debian/Ubuntu: sudo apt install git  ·  https://git-scm.com"));
+    }
+    if (!db.ok) {
+        blocked = true;
+        console.log("\n" + C.red("✗ ") + db.message);
+    }
+    const results = await connectAgents();
+    if (!nextSteps(results))
+        blocked = true;
+    return blocked ? 1 : 0;
+}
+/** What to do when agents are missing or signed out. Returns true if at least one is ready. */
+function nextSteps(results) {
+    const ready = results.filter((r) => r.state === "ready");
+    if (ready.length) {
+        console.log(C.faint(`\n  ${ready.length} agent(s) ready — cd into a repo and run: huddle`));
+        return true;
+    }
+    const missing = results.filter((r) => r.state === "not_installed" && !LEGACY.has(r.adapter.id));
+    console.log(`\n${C.yellow("No agents ready yet.")} Huddle runs the coding agents you already use, each signed in to its own account.`);
+    if (missing.length) {
+        console.log(C.faint("  Install one or more (or run `huddle` — it offers to, and asks first):"));
+        for (const r of missing)
+            console.log(`    ${dot(r.adapter.id)} ${C.bold(r.adapter.id.padEnd(12))} ${C.faint("$")} ${r.adapter.install.cmd}`);
+    }
+    console.log(C.faint("  Then sign in with the agent itself — Huddle never sees your credentials — and run `huddle doctor` again."));
+    return false;
+}
+//# sourceMappingURL=doctor.js.map

package/dist/ui/logo.js

@@ -0,0 +1,40 @@
+// The Huddle mark (teaser/assets/huddle-logo.svg: four heavy rings in a plus)
+// rasterized to half-block characters (▀ ▄ █). Each cell is one pixel wide and
+// two tall, so pixels come out square and the rings render solid in any font.
+const RINGS = [
+    [0, -43.5],
+    [43.5, 0],
+    [0, 43.5],
+    [-43.5, 0],
+];
+const R = 56;
+const HALF_STROKE = 11;
+const VIEW = 224; // svg viewBox is -112..112
+const inRing = (x, y) => RINGS.some(([cx, cy]) => Math.abs(Math.hypot(x - cx, y - cy) - R) <= HALF_STROKE);
+/** Fraction of pixel (px, py) on a W×H grid covered by the rings. */
+function coverage(px, py, W, H, ss = 6) {
+    let hits = 0;
+    for (let i = 0; i < ss; i++)
+        for (let j = 0; j < ss; j++) {
+            const x = -VIEW / 2 + ((px + (i + 0.5) / ss) / W) * VIEW;
+            const y = -VIEW / 2 + ((py + (j + 0.5) / ss) / H) * VIEW;
+            if (inRing(x, y))
+                hits++;
+        }
+    return hits / (ss * ss);
+}
+/** Render the logo as `rows` lines of `cols` cells. 16×8 is the tuned size. */
+export function logoLines(cols = 16, rows = 8, threshold = 0.42) {
+    const out = [];
+    for (let r = 0; r < rows; r++) {
+        let line = "";
+        for (let c = 0; c < cols; c++) {
+            const top = coverage(c, r * 2, cols, rows * 2) >= threshold;
+            const bot = coverage(c, r * 2 + 1, cols, rows * 2) >= threshold;
+            line += top && bot ? "█" : top ? "▀" : bot ? "▄" : " ";
+        }
+        out.push(line);
+    }
+    return out;
+}
+//# sourceMappingURL=logo.js.map