huddle-cli 0.0.0-stage → 0.1.0

package/dist/ui/term.js

@@ -0,0 +1,114 @@
+// Terminal primitives: color, width-aware padding, the rounded box, spinners.
+// Huddle lives in the terminal only, so this file is the whole "UI toolkit".
+const color = process.stdout.isTTY && !process.env.NO_COLOR;
+const sgr = (open) => (s) => (color ? `\x1b[${open}m${s}\x1b[0m` : s);
+const hex = (h) => {
+    const n = parseInt(h.slice(1), 16);
+    return sgr(`38;2;${(n >> 16) & 255};${(n >> 8) & 255};${n & 255}`);
+};
+// Brand palette — matches the teaser (teaser/launch40.html).
+export const C = {
+    dim: sgr("2"),
+    bold: sgr("1"),
+    green: sgr("32"),
+    red: sgr("31"),
+    yellow: sgr("33"),
+    violet: hex("#7B6CF6"),
+    faint: hex("#8A857C"),
+    hex,
+};
+export const AGENT_COLOR = {
+    claude: "#D9774B",
+    codex: "#10A37F",
+    antigravity: "#4285F4",
+    gemini: "#4285F4",
+    cursor: "#8A8A8A",
+    opencode: "#E5C07B",
+    copilot: "#8957E5",
+    amp: "#F34E3F",
+    goose: "#B8B2A7",
+    qwen: "#615CED",
+    droid: "#EE6018",
+    kiro: "#9046FF",
+};
+/** Colored dot for an agent; "claude#2" gets Claude's color. */
+export const dot = (agentId) => hex(AGENT_COLOR[agentId.split("#")[0]] ?? "#8A857C")("●");
+/** Visible width of a string (ignores ANSI escapes). */
+export function width(s) {
+    return [...s.replace(/\x1b\[[0-9;]*m/g, "")].length;
+}
+/** Cut to `n` visible characters, keeping color codes intact. */
+export function truncate(s, n) {
+    if (width(s) <= n)
+        return s;
+    let out = "";
+    let seen = 0;
+    for (let i = 0; i < s.length;) {
+        const esc = /^\x1b\[[0-9;]*m/.exec(s.slice(i));
+        if (esc) {
+            out += esc[0];
+            i += esc[0].length;
+            continue;
+        }
+        const ch = String.fromCodePoint(s.codePointAt(i));
+        if (seen >= n - 1)
+            return out + "…\x1b[0m";
+        out += ch;
+        seen++;
+        i += ch.length;
+    }
+    return out;
+}
+export function pad(s, n) {
+    return s + " ".repeat(Math.max(0, n - width(s)));
+}
+/** Rounded box with a colored border, Claude-Code style. */
+export function box(lines, opts = {}) {
+    const border = opts.border ?? C.violet;
+    const inner = Math.max(opts.width ?? 0, ...lines.map(width)) + 2;
+    const top = border("╭" + "─".repeat(inner) + "╮");
+    const bot = border("╰" + "─".repeat(inner) + "╯");
+    const mid = lines.map((l) => border("│") + " " + pad(l, inner - 2) + " " + border("│"));
+    return [top, ...mid, bot].join("\n");
+}
+const FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+/** A set of lines that re-render in place while async work settles. */
+export class LiveLines {
+    render;
+    lines;
+    frame = 0;
+    timer;
+    drawn = false;
+    constructor(render) {
+        this.render = render;
+        this.lines = [];
+    }
+    start() {
+        this.draw();
+        if (process.stdout.isTTY)
+            this.timer = setInterval(() => this.draw(), 80);
+        return this;
+    }
+    draw() {
+        if (!process.stdout.isTTY)
+            return; // non-TTY: draw once at stop()
+        const next = this.render(C.violet(FRAMES[this.frame++ % FRAMES.length]));
+        if (this.drawn)
+            process.stdout.write(`\x1b[${this.lines.length}A`);
+        for (const l of next)
+            process.stdout.write("\x1b[2K" + l + "\n");
+        this.lines = next;
+        this.drawn = true;
+    }
+    stop() {
+        if (this.timer)
+            clearInterval(this.timer);
+        if (!process.stdout.isTTY) {
+            for (const l of this.render(" "))
+                process.stdout.write(l + "\n");
+            return;
+        }
+        this.draw();
+    }
+}
+//# sourceMappingURL=term.js.map

package/dist/ui/watch.js

@@ -0,0 +1,174 @@
+// `huddle view [repo]` — the live view (ctrl-t) from a second terminal.
+//
+// A run started anywhere — `huddle`, `huddle join "<goal>"`, a script, the
+// e2e evals — writes everything to the repo's Room db. This opens the same
+// full-screen dashboard on that db, read-only: agent panes, plan + room
+// talk, board + shared memory. It never claims, edits or stops anything;
+// q or ctrl-c just closes the view.
+import fs from "node:fs";
+import path from "node:path";
+import readline from "node:readline";
+import { spawnSync } from "node:child_process";
+import { RoomDB } from "../room/db.js";
+import { C } from "./term.js";
+import { Dashboard } from "./dashboard.js";
+const json = (s) => {
+    try {
+        return JSON.parse(s || "{}");
+    }
+    catch {
+        return {};
+    }
+};
+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. */
+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)}` };
+        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)}` };
+        case "plan.announced":
+            return { agent: who, text: `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)}”` };
+        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)}` };
+        case "run.merged":
+            return { agent: who, text: `✓ 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 { text: `${p.from} → ${p.to}: ${clip(p.body)}` };
+        case "memory.added":
+            return { text: `◆ ${p.author ?? who ?? "memory"}: ${clip(p.body)}` };
+        case "council.proposal":
+            return { agent: who, text: `proposes: ${clip(p.text)}` };
+        case "council.critique":
+            return { agent: who, text: `flags: ${clip(p.text)}` };
+        case "council.plan":
+            return { text: `◇ council plan ready` };
+        case "qa.round":
+            return { text: `◎ QA round ${p.round} · ${(p.agents ?? []).join(", ")}` };
+        case "qa.bug":
+            return { text: `🐞 ${who ?? "QA"} found: ${clip(p.title ?? p.body)}` };
+        case "qa.clean":
+            return { text: `✓ QA round ${p.round ?? ""} clean` };
+        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 null;
+    }
+}
+/** Busy/tokens/tasks per agent, rebuilt from the run's events (another process owns the live stats). */
+export function statsOf(db, events) {
+    const session = db.currentSession();
+    const since = session?.created_at ?? 0;
+    const run = events.filter((e) => e.ts >= since);
+    const starts = run.filter((e) => e.type === "run.start");
+    if (!starts.length && !db.listAgents().length)
+        return null;
+    const agents = new Map();
+    const get = (id) => {
+        if (!agents.has(id))
+            agents.set(id, { busySince: null, liveTokens: 0, tokens: 0, tasks: 0, reviews: 0 });
+        return agents.get(id);
+    };
+    for (const a of db.listAgents())
+        if (!ROOM_AUTHORS.has(a.id))
+            get(a.id);
+    for (const e of run) {
+        const p = json(e.payload);
+        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 === "run.merged" || e.type === "run.failed" || e.type === "run.reviewed") {
+            a.busySince = null;
+            if (e.type === "run.merged")
+                a.tasks++;
+            if (e.type === "run.reviewed")
+                a.reviews++;
+            a.tokens += Number(p.tokens) || 0;
+        }
+    }
+    return { startedAt: starts[0]?.ts ?? since, 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);
+    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)",
+    });
+    // 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)) {
+            if (e.ts < since)
+                continue;
+            const a = activityOf(e);
+            if (a && !a.agent && e.type === "task.progress" && e.task_id) {
+                const owner = db.getTask(e.task_id)?.claimed_by;
+                if (owner)
+                    a.agent = owner;
+            }
+            if (a)
+                dash.push(a);
+        }
+        seen = list.length;
+    };
+    feed(events);
+    const poll = setInterval(() => {
+        events = db.allEvents();
+        stats = statsOf(db, events);
+        feed(events);
+    }, 1000);
+    readline.emitKeypressEvents(process.stdin);
+    process.stdin.setRawMode(true);
+    await new Promise((resolve) => {
+        const quit = (_s, key) => {
+            if (key?.ctrl && key.name === "c")
+                close();
+        };
+        const close = () => {
+            process.stdin.off("keypress", quit);
+            dash.hide();
+            resolve();
+        };
+        process.stdin.on("keypress", quit);
+        dash.show(undefined, close);
+    });
+    clearInterval(poll);
+    process.stdin.setRawMode(false);
+    db.close();
+    process.exit(0);
+}
+//# sourceMappingURL=watch.js.map

package/install.sh

@@ -0,0 +1,44 @@
+#!/bin/sh
+# Huddle installer.
+#   curl -fsSL <this file> | sh
+# Installs the `huddle` CLI from npm (huddle-cli). Then run `huddle`: it finds
+# your agents (claude, codex, antigravity, cursor) and offers to install or
+# sign in to the missing ones — always asking first. Huddle never handles
+# your agents' credentials; each one signs in on its own.
+#
+#   HUDDLE_SOURCE=<spec>   install something else, e.g. a local .tgz or github:Preet37/Huddle
+set -e
+
+violet() { printf '\033[38;2;123;108;246m%s\033[0m\n' "$1"; }
+fail() { printf '\033[31m✗ %s\033[0m\n' "$1" >&2; exit 1; }
+
+command -v node >/dev/null 2>&1 || fail "Node.js 20+ is required — https://nodejs.org (or: nvm install 22)"
+major=$(node -p 'process.versions.node.split(".")[0]')
+[ "$major" -ge 20 ] || fail "Node.js 20+ is required (found $(node -v)) — https://nodejs.org (or: nvm install 22)"
+command -v npm >/dev/null 2>&1 || fail "npm is required (it ships with Node.js — https://nodejs.org)"
+command -v git >/dev/null 2>&1 || fail "git is required — macOS: xcode-select --install · Linux: your package manager"
+
+# A system-wide Node often has a root-owned global folder; npm would then
+# fail with EACCES halfway through. Say so up front instead of using sudo.
+prefix=$(npm prefix -g 2>/dev/null || true)
+if [ -n "$prefix" ] && [ -d "$prefix/lib" ] && [ ! -w "$prefix/lib" ]; then
+  fail "npm can't write to $prefix/lib (global installs need root there).
+  Pick one, then re-run this installer:
+    • use a Node version manager (no root needed):  https://github.com/nvm-sh/nvm
+    • or give npm a folder you own:  npm config set prefix ~/.npm-global && export PATH=~/.npm-global/bin:\$PATH"
+fi
+
+violet "↓ installing huddle…"
+# (A github: source builds with devDependencies; the teaser renderer's Chromium isn't needed.)
+PUPPETEER_SKIP_DOWNLOAD=1 npm install -g "${HUDDLE_SOURCE:-huddle-cli}"
+
+echo
+if command -v huddle >/dev/null 2>&1; then
+  violet "✓ huddle $(huddle --version) installed"
+  echo "  cd into any git repo and run:  huddle"
+  echo "  check this machine any time:   huddle doctor"
+else
+  violet "✓ huddle installed in $prefix/bin"
+  echo "  that folder isn't on your PATH yet — add it, e.g.:"
+  echo "    export PATH=\"$prefix/bin:\$PATH\""
+fi

package/package.json

@@ -1,6 +1,62 @@
 {
   "name": "huddle-cli",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "description": "The multiplayer layer for AI coding agents. One command. Every agent. One repo. Zero collisions.",
+  "type": "module",
+  "bin": {
+    "huddle": "dist/cli.js"
+  },
+  "files": [
+    "dist/**/*.js",
+    "install.sh",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Preet37/Huddle.git"
+  },
+  "homepage": "https://github.com/Preet37/Huddle#readme",
+  "bugs": {
+    "url": "https://github.com/Preet37/Huddle/issues"
+  },
+  "scripts": {
+    "build": "node -e \"require('fs').rmSync('dist',{recursive:true,force:true})\" && tsc",
+    "dev": "tsc --watch",
+    "start": "node dist/cli.js",
+    "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"
+  },
+  "keywords": [
+    "ai",
+    "agents",
+    "multiplayer",
+    "mcp",
+    "claude",
+    "codex",
+    "gemini",
+    "cursor",
+    "orchestration"
+  ],
+  "license": "MIT",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "nanoid": "^5.0.0",
+    "ws": "^8.18.0"
+  },
+  "optionalDependencies": {
+    "better-sqlite3": "^11.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "@types/ws": "^8.5.0",
+    "puppeteer": "^24.43.1",
+    "typescript": "^5.6.0"
+  }
+}