huddle-cli 0.1.0 → 0.1.3

package/dist/ui/watch.js

@@ -23,47 +23,115 @@ const json = (s) => {
 const clip = (s, n = 160) => String(s ?? "").replace(/\s+/g, " ").trim().slice(0, n);
 /** Writers in the room that aren't agents — no pane of their own. */
 const ROOM_AUTHORS = new Set(["council", "huddle", "brain", "qa"]);
-/** One persisted event → a line for an agent's pane (agent set) or the room strip. */
+/**
+ * One persisted event → a line for an agent's pane (agent set) or the room strip.
+ * The same words and glyphs as the run's own output: ▸ start, ✓ done, ✗ failed or
+ * a bug, ◎ a review or buddy check, ◆ the contract or memory, ⚠ radar, ⇉ a pair.
+ */
 export function activityOf(e) {
     const p = json(e.payload);
     const who = e.agent_id ?? p.agent;
     switch (e.type) {
         case "run.start":
-            return { agent: who, text: `▸ ${clip(p.title)}` };
+            return { agent: who, text: `${C.violet("▸")} ${clip(p.title)}` };
         case "task.progress":
             // Progress rows carry the task, not always the agent; runView resolves the owner.
             if (!clip(p.note))
                 return null;
-            return { agent: who, text: `${p.pct}%  ${clip(p.note)}` };
+            return { agent: who, text: `${C.faint(`${p.pct}%`)}  ${clip(p.note)}` };
         case "plan.announced":
-            return { agent: who, text: `plans: ${clip(p.summary ?? p.plan ?? p.intent ?? p.title)}` };
+            return { agent: who, text: `${C.faint("plans:")} ${clip(p.summary ?? p.plan ?? p.intent ?? p.title)}` };
         case "run.review":
-            return { agent: who, text: `◎ reviewing ${p.author}'s “${clip(p.title, 60)}”` };
+            return { agent: who, text: `${C.violet("◎")} reviewing ${p.author}'s “${clip(p.title, 60)}”` };
         case "run.reviewed":
-            return { agent: who, text: p.skipped ? `review skipped (${clip(p.notes, 40)})` : p.approve ? `✓ approved ${p.author}'s work` : `✗ asked ${p.author} for changes: ${clip(p.notes)}` };
+            return {
+                agent: who,
+                text: p.skipped
+                    ? C.faint(`review skipped (${clip(p.notes, 40)})`)
+                    : p.approve
+                        ? `${C.green("✓ approved")} ${p.author}'s work`
+                        : `${C.yellow("✎ asked")} ${p.author} for changes: ${clip(p.notes)}`,
+            };
         case "run.merged":
-            return { agent: who, text: `✓ merged ${clip(p.title, 80)}` };
+            return { agent: who, text: `${C.green("✓ merged")} ${clip(p.title, 80)}` };
         case "run.failed":
-            return { agent: who, text: `✗ failed ${clip(p.title, 60)} — ${clip(p.reason ?? p.error, 80)}` };
-        case "agent.message":
+            return { agent: who, text: `${C.red("✗ failed")} ${clip(p.title, 60)} — ${clip(p.reason ?? p.error, 80)}` };
+        case "agent.message": {
+            // Huddle relaying a buddy check: say it as the teammate's note it is.
+            const b = /^buddy check from (\S+) (?:at )?([^:\n]*):\s*([\s\S]*)$/i.exec(String(p.body ?? ""));
+            if (p.from === "huddle" && b)
+                return { text: `${C.violet("◎")} ${b[1]} → ${p.to} ${C.faint(`(buddy note, ${b[2].trim()})`)}: ${clip(b[3])}` };
             return { text: `${p.from} → ${p.to}: ${clip(p.body)}` };
-        case "memory.added":
-            return { text: `◆ ${p.author ?? who ?? "memory"}: ${clip(p.body)}` };
+        }
+        case "memory.added": {
+            const body = String(p.body ?? "");
+            // Each of these is already its own line: a merged task, a QA bug, a message.
+            if (/^Task \S+ done:|^QA \(\S+\) found:|^\S+ → \S+:/.test(body))
+                return null;
+            const author = p.author ?? who ?? "memory";
+            const risk = /^council risk(?: \(\w+\))?:\s*/i.exec(body);
+            if (risk)
+                return { text: `${C.yellow("!")} ${author} risk: ${clip(body.slice(risk[0].length))}` };
+            return { text: `${C.violet("◆")} ${author}: ${clip(body.replace(new RegExp(`^${author}:\\s*`), ""))}` };
+        }
         case "council.proposal":
-            return { agent: who, text: `proposes: ${clip(p.text)}` };
+            return { agent: who, text: `${C.faint("proposes:")} ${clip(p.text)}` };
         case "council.critique":
-            return { agent: who, text: `flags: ${clip(p.text)}` };
+            return { agent: who, text: `${C.faint("flags:")} ${clip(p.text)}` };
+        case "council.adopt":
+            return { agent: who, text: `${C.green("+ adopts")} ${p.of}'s idea: ${clip(p.body)}` };
+        case "council.flaw":
+            return { agent: who, text: `${C.yellow("! flaw in")} ${p.of}'s idea: ${clip(p.body)}` };
+        case "council.ratify":
+            return {
+                agent: who,
+                text: p.verdict === "object" ? `${C.yellow("objects")} to the contract: ${clip((p.objections ?? []).join(" · "))}` : `${C.green("✓ ratifies")} the contract`,
+            };
         case "council.plan":
-            return { text: `◇ council plan ready` };
+            return { text: `${C.violet("◇")} council plan ready${p.synthesizer?.id ? ` · written by ${p.synthesizer.id}` : ""}` };
+        case "contract.set":
+            return p.text ? { text: `${C.violet("◆")} contract v1 by ${p.by ?? "council"} · the names every task codes to` } : null;
+        case "contract.amended":
+            return { text: `${C.violet("◆")} contract v${p.version} by ${p.by}: ${clip(`${p.section}: ${p.change}`)}` };
+        case "run.radar":
+            return { agent: who, text: `${C.yellow("⚠ radar:")} ${p.kind === "overlap" ? "overlap" : "name mismatch"} with ${p.with} · ${clip(p.detail)}` };
+        case "run.checkpoint": {
+            const ok = /^LOOKS GOOD/i.test(String(p.notes ?? "").trim());
+            return {
+                agent: who,
+                text: `${C.violet("◎")} buddy check on ${p.author}'s work ${p.pct ? `at ${p.pct}%` : "mid-task"}: ${ok ? C.green("looks good") : `${p.late ? "(came back after it landed) " : ""}${clip(p.notes)}`}`,
+            };
+        }
+        case "note.closed":
+            return {
+                agent: p.to ?? who,
+                text: `${C.violet("◎")} ${p.kind === "radar" ? "radar finding" : `${p.by}'s buddy note`} ${p.how === "ignored" ? C.yellow("ignored") : C.green(p.how === "replied" ? "answered" : "addressed in code")}: ${clip(p.body, 100)}`,
+            };
+        case "run.busy":
+            return { agent: who, text: `${C.faint("⧗ running a long command")} · quiet ${Math.round((Number(p.quietMs) || 0) / 60_000) || "<1"} min, not silent: ${clip(p.why, 80)}` };
+        case "run.budget":
+            return { text: `${C.yellow("! token budget")} ${p.level === "hard" ? "ran over — agents stopped" : "nearly spent — no new work"}${(p.left ?? []).length ? ` · left undone: ${clip((p.left ?? []).join(" · "), 80)}` : ""}` };
+        case "run.pair":
+            return { agent: who, text: `${C.violet("⇉")} pairs with ${p.with} on “${clip(p.title, 60)}”: ${clip(p.part, 80)}` };
         case "qa.round":
-            return { text: `◎ QA round ${p.round} · ${(p.agents ?? []).join(", ")}` };
+            return { text: `${C.violet("◎")} QA round ${p.round} · ${(p.agents ?? []).join(", ")}` };
         case "qa.bug":
-            return { text: `🐞 ${who ?? "QA"} found: ${clip(p.title ?? p.body)}` };
+            return { text: `${C.yellow("✗")} ${who ?? "QA"} found a bug: ${clip(p.title ?? p.body)}` };
+        case "qa.done":
+            return { agent: who, text: p.ok ? `${C.green("✓ QA done")} · ${p.bugs ?? 0} bug(s) filed` : C.yellow("! QA didn't finish") };
         case "qa.clean":
-            return { text: `✓ QA round ${p.round ?? ""} clean` };
+            return { text: `${C.green("✓")} QA round ${p.round ?? ""} clean` };
+        case "qa.suspect":
+            return { text: `${C.yellow("?")} QA round ${p.round ?? ""} clean, but quick: a second agent checks` };
+        case "context.added":
+            return { text: `${C.violet("+")} ${p.by ?? "you"} put ${p.id} on the screen: “${clip(p.title, 60)}”` };
+        case "context.note":
+            return { text: `${C.violet("◆")} ${p.by ?? who} on ${p.id}: ${clip(p.body)}` };
+        case "context.read":
+            return who ? { agent: who, text: `${C.faint("read")} ${p.id} “${clip(p.title, 50)}”${p.from ? ` lines ${p.from}-${p.to}` : ""}` } : null;
         default:
             if (e.type.startsWith("takeover") || e.type === "run.takeover")
-                return { text: `⇄ ${p.to ?? who} took over ${p.from}'s “${clip(p.title, 60)}” (${clip(p.reason, 40)})` };
+                return { text: `${C.yellow("⤳")} ${p.to ?? who} took over ${p.from}'s “${clip(p.title, 60)}” (${clip(p.reason, 40)})` };
             return null;
     }
 }
@@ -86,12 +154,21 @@ export function statsOf(db, events) {
             get(a.id);
     for (const e of run) {
         const p = json(e.payload);
+        // A QA round: its checkers are busy until each one's qa.done.
+        if (e.type === "qa.round")
+            for (const q of (p.agents ?? []))
+                if (!ROOM_AUTHORS.has(q))
+                    get(q).busySince = e.ts;
         const id = e.agent_id ?? p.agent;
         if (!id || ROOM_AUTHORS.has(id))
             continue;
         const a = get(id);
         if (e.type === "run.start" || e.type === "run.review")
             a.busySince = e.ts;
+        else if (e.type === "qa.done") {
+            a.busySince = null;
+            a.qa = (a.qa ?? 0) + 1;
+        }
         else if (e.type === "run.merged" || e.type === "run.failed" || e.type === "run.reviewed") {
             a.busySince = null;
             if (e.type === "run.merged")
@@ -101,37 +178,39 @@ export function statsOf(db, events) {
             a.tokens += Number(p.tokens) || 0;
         }
     }
-    return { startedAt: starts[0]?.ts ?? since, agents };
+    // Over: nobody busy and every task landed or failed. The clock stops at the last event.
+    const busy = [...agents.values()].some((a) => a.busySince);
+    const tasks = db.listTasks();
+    const over = !busy && tasks.length > 0 && tasks.every((t) => t.status === "merged" || t.status === "failed");
+    return { startedAt: starts[0]?.ts ?? since, ...(over && run.length ? { endedAt: run[run.length - 1].ts } : {}), agents };
 }
-function repoRoot(dir) {
-    const r = spawnSync("git", ["rev-parse", "--show-toplevel"], { cwd: dir, encoding: "utf8" });
-    return r.status === 0 ? r.stdout.trim() : dir;
-}
-export async function runView(args) {
-    const root = repoRoot(path.resolve(args.find((a) => !a.startsWith("-")) ?? process.cwd()));
-    const file = path.join(root, ".huddle", "huddle.db");
-    if (!fs.existsSync(file)) {
-        console.log(C.red("✗ No Huddle room here yet.") + ` Start a run in ${root} (huddle, or huddle join "<goal>"), then run huddle view.`);
-        process.exit(1);
-    }
-    if (!process.stdout.isTTY || !process.stdin.isTTY) {
-        console.log(C.red("✗ huddle view needs a terminal.") + " For a plain-text replay use: huddle story");
-        process.exit(1);
-    }
-    const db = new RoomDB(file);
-    let events = db.allEvents();
-    let stats = statsOf(db, events);
+/**
+ * The read-only view on a Room db: the dashboard, fed this run's events so
+ * far. refresh() picks up what another process wrote since. (runView polls
+ * it; the samples and tests call frame() on it directly.)
+ */
+export function viewOf(db) {
+    let events = [];
+    let stats = null;
     const dash = new Dashboard({
         db: () => db,
         stats: () => stats,
         modeChip: () => C.faint("watching · read-only"),
         hint: "1 2 3 switch · q close the view (agents keep working)",
+        empty: "waiting for a run — agents show up here as they pick up tasks",
     });
-    // Replay this run's feed so the panes aren't empty when you open late.
-    const since = db.currentSession()?.created_at ?? 0;
     let seen = 0; // events come back ordered by (ts, rowid), so new ones are a suffix
-    const feed = (list) => {
-        for (const e of list.slice(seen)) {
+    let since = -1;
+    const refresh = () => {
+        events = db.allEvents();
+        stats = statsOf(db, events);
+        // A new run (a new session) starts the panes over.
+        const s = db.currentSession()?.created_at ?? 0;
+        if (s !== since) {
+            since = s;
+            seen = 0;
+        }
+        for (const e of events.slice(seen)) {
             if (e.ts < since)
                 continue;
             const a = activityOf(e);
@@ -143,14 +222,36 @@ export async function runView(args) {
             if (a)
                 dash.push(a);
         }
-        seen = list.length;
+        seen = events.length;
     };
-    feed(events);
-    const poll = setInterval(() => {
-        events = db.allEvents();
-        stats = statsOf(db, events);
-        feed(events);
-    }, 1000);
+    refresh();
+    return { dash, refresh };
+}
+function repoRoot(dir) {
+    const r = spawnSync("git", ["rev-parse", "--show-toplevel"], { cwd: dir, encoding: "utf8" });
+    return r.status === 0 ? r.stdout.trim() : dir;
+}
+export async function runView(args) {
+    const root = repoRoot(path.resolve(args.find((a) => !a.startsWith("-")) ?? process.cwd()));
+    const file = path.join(root, ".huddle", "huddle.db");
+    if (!process.stdout.isTTY || !process.stdin.isTTY) {
+        if (!fs.existsSync(file))
+            console.log(C.red("✗ No Huddle room here yet.") + ` Start a run in ${root} (huddle, or huddle join "<goal>"), then run huddle view.`);
+        else
+            console.log(C.red("✗ huddle view needs a terminal.") + " For a plain-text replay use: huddle story");
+        process.exit(1);
+    }
+    // Opened before the first run here: wait for its room instead of giving up.
+    if (!fs.existsSync(file)) {
+        console.log(`${C.faint("○")} No room in ${root} yet. ${C.faint('Waiting for a run to start here (huddle, or huddle join "<goal>") · ctrl-c to stop')}`);
+        await new Promise((resolve) => {
+            const t = setInterval(() => fs.existsSync(file) && (clearInterval(t), resolve()), 1000);
+        });
+    }
+    const db = new RoomDB(file);
+    // Replay this run's feed so the panes aren't empty when you open late.
+    const { dash, refresh } = viewOf(db);
+    const poll = setInterval(refresh, 1000);
     readline.emitKeypressEvents(process.stdin);
     process.stdin.setRawMode(true);
     await new Promise((resolve) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "huddle-cli",
-  "version": "0.1.0",
+  "version": "0.1.3",
   "description": "The multiplayer layer for AI coding agents. One command. Every agent. One repo. Zero collisions.",
   "type": "module",
   "bin": {
@@ -9,6 +9,8 @@
   "files": [
     "dist/**/*.js",
     "install.sh",
+    "QUICKSTART.md",
+    "CHANGELOG.md",
     "README.md",
     "LICENSE"
   ],
@@ -30,8 +32,9 @@
     "typecheck": "tsc --noEmit && tsc -p tsconfig.test.json --noEmit",
     "prepare": "npm run build",
     "prepublishOnly": "npm run typecheck && npm test",
-    "test": "rm -rf .test-build && tsc -p tsconfig.test.json && HUDDLE_NO_AGENTS_FILE=1 node --test --test-concurrency=1 .test-build/test/*.test.js",
-    "e2e": "npm run build && rm -rf .test-build && tsc -p tsconfig.test.json && node .test-build/test/e2e/run.js"
+    "test": "node scripts/test.mjs",
+    "e2e": "npm run build && node scripts/test.mjs e2e",
+    "evolve": "npm run build && node scripts/test.mjs evolve"
   },
   "keywords": [
     "ai",