huddle-cli 0.0.0-stage → 0.1.1

package/dist/ui/term.js

@@ -0,0 +1,249 @@
+// 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;
+/**
+ * A console that can't draw Huddle's glyphs: the old Windows console host
+ * (conhost: cmd.exe or PowerShell outside Windows Terminal) shows ⤳, ⇉,
+ * braille spinners and emoji as boxes or "?". HUDDLE_ASCII=1 forces plain
+ * ASCII anywhere; HUDDLE_ASCII=0 turns it off. Windows Terminal sets
+ * WT_SESSION, VS Code's terminal sets TERM_PROGRAM, ConEmu sets ConEmuANSI.
+ */
+export function legacyConsole(env = process.env, platform = process.platform) {
+    if (env.HUDDLE_ASCII === "1")
+        return true;
+    if (env.HUDDLE_ASCII === "0")
+        return false;
+    return platform === "win32" && !env.WT_SESSION && !env.TERM_PROGRAM && env.ConEmuANSI !== "ON";
+}
+export const ASCII = legacyConsole();
+const ASCII_MAP = {
+    "●": "*", "○": "o", "✓": "v", "✗": "x", "▸": ">", "◎": "@", "◆": "#", "◇": "#", "⚠": "!", "⇉": "=>", "⇢": "->",
+    "⤳": "~>", "⇄": "<>", "→": "->", "←": "<-", "↑": "^", "↓": "v", "…": "...", "·": "-", "—": "-", "–": "-", "“": '"', "”": '"',
+    "‘": "'", "’": "'", "─": "-", "━": "=", "│": "|", "╭": "+", "╮": "+", "╰": "+", "╯": "+", "┌": "+", "┐": "+", "└": "+", "┘": "+",
+    "█": "#", "░": ".", "▶": ">", "■": "#", "✎": "*", "⬢": "#", "⏱": "", "⚡": "!", "×": "x", "≥": ">=", "≤": "<=", "\uFE0F": "",
+};
+const ASCII_RE = new RegExp(`[${Object.keys(ASCII_MAP).join("")}]|[\u{1F000}-\u{1FAFF}\u{2600}-\u{27BF}]\uFE0F?|\uFE0F|[\u2800-\u28FF]`, "gu");
+/** Huddle's glyphs → ASCII, for legacy consoles (escape codes pass through). */
+export function toAscii(s) {
+    return s.replace(ASCII_RE, (c) => ASCII_MAP[c] ?? ASCII_MAP[c.replace("\uFE0F", "")] ?? (c >= "\u2800" && c <= "\u28FF" ? "|" : "*"));
+}
+/** In a legacy console, every write to stdout/stderr goes through toAscii (once, at startup). */
+export function useAsciiOutput(on = ASCII) {
+    if (!on)
+        return;
+    for (const stream of [process.stdout, process.stderr]) {
+        const write = stream.write.bind(stream);
+        stream.write = (chunk, ...rest) => write(typeof chunk === "string" ? toAscii(chunk) : chunk, ...rest);
+    }
+}
+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")("●");
+/** Terminal cells for one character: emoji and CJK take two, combining marks none. */
+function cells(ch) {
+    const c = ch.codePointAt(0);
+    if (c === 0xfe0f || c === 0x200d || (c >= 0x300 && c <= 0x36f))
+        return 0;
+    if ((c >= 0x1f300 && c <= 0x1faff) || (c >= 0x1100 && c <= 0x115f) || (c >= 0x2e80 && c <= 0xa4cf) || (c >= 0xac00 && c <= 0xd7a3) || (c >= 0xf900 && c <= 0xfaff) || (c >= 0xff00 && c <= 0xff60))
+        return 2;
+    return 1;
+}
+/** Visible width of a string in terminal cells (ignores ANSI escapes). */
+export function width(s) {
+    let n = 0;
+    for (const ch of s.replace(/\x1b\[[0-9;]*m/g, ""))
+        n += cells(ch);
+    return n;
+}
+/** 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));
+        const w = cells(ch);
+        if (seen + w > n - 1)
+            return out + "…" + (out.includes("\x1b[") ? "\x1b[0m" : "");
+        out += ch;
+        seen += w;
+        i += ch.length;
+    }
+    return out;
+}
+/** Word-wrap plain or colored text to `n` cells; `indent` starts every line after the first. */
+export function wrap(s, n, indent = "") {
+    const lead = /^ */.exec(s)[0];
+    if (!indent.startsWith(lead))
+        indent = lead + indent;
+    const out = [];
+    let line = lead;
+    for (const word of s.slice(lead.length).split(/ +/)) {
+        if (line.trim() && width(line) + 1 + width(word) > n) {
+            out.push(line);
+            line = indent + word;
+        }
+        else
+            line = line.trim() ? line + " " + word : line + word;
+    }
+    out.push(line);
+    return out.map((l) => truncate(l, n + 1));
+}
+/** Columns to fit printed lines to: the terminal's (minus one, so nothing auto-wraps), or none when piped. */
+export function lineWidth(out = process.stdout) {
+    return out.isTTY ? Math.max(20, (out.columns || 80) - 1) : null;
+}
+/** One printed line, cut to the terminal (no-op when piped: logs keep everything). */
+export function fit(s, out = process.stdout) {
+    const w = lineWidth(out);
+    return w === null ? s : s.split("\n").map((l) => truncate(l, w)).join("\n");
+}
+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 = ASCII ? ["|", "/", "-", "\\"] : ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+/**
+ * A set of lines that re-render in place while async work settles. Each row
+ * is cut to the terminal's width: a row that wraps takes two screen lines,
+ * so moving the cursor up "one per row" would land mid-list and every redraw
+ * would print the list again further down (seen on Windows: rows doubled and
+ * spliced, "API_KEYodex · openai").
+ */
+export class LiveLines {
+    render;
+    out;
+    lines;
+    frame = 0;
+    timer;
+    drawn = false;
+    constructor(render, out = process.stdout) {
+        this.render = render;
+        this.out = out;
+        this.lines = [];
+    }
+    start() {
+        this.draw();
+        if (this.out.isTTY)
+            this.timer = setInterval(() => this.draw(), 80);
+        return this;
+    }
+    /** One screen line per row: never wider than the terminal (minus one, so no auto-wrap). */
+    fit(l) {
+        return truncate(l.replace(/[\r\n]+/g, " "), Math.max(10, (this.out.columns || 80) - 1));
+    }
+    draw() {
+        if (!this.out.isTTY)
+            return; // non-TTY: draw once at stop()
+        const next = this.render(C.violet(FRAMES[this.frame++ % FRAMES.length])).map((l) => this.fit(l));
+        let s = this.drawn && this.lines.length ? `\x1b[${this.lines.length}A` : "";
+        for (const l of next)
+            s += "\x1b[2K" + l + "\n";
+        this.out.write(s); // one write: no half-drawn frame
+        this.lines = next;
+        this.drawn = true;
+    }
+    stop() {
+        if (this.timer)
+            clearInterval(this.timer);
+        if (!this.out.isTTY) {
+            for (const l of this.render(" "))
+                this.out.write(l + "\n");
+            return;
+        }
+        this.draw();
+    }
+}
+/**
+ * Lines pinned under scrolling output — the run's status block. log() prints
+ * a line above them and redraws them; nothing else should write to `out`
+ * while the dock is up. TTY only: piped output (a log file) gets the logged
+ * lines and never the dock.
+ */
+export class Dock {
+    render;
+    out;
+    n = 0;
+    timer;
+    up = false;
+    constructor(render, out = process.stdout) {
+        this.render = render;
+        this.out = out;
+    }
+    paint() {
+        const w = Math.max(10, (this.out.columns || 80) - 1);
+        const ls = this.render().map((l) => truncate(l.replace(/[\r\n]+/g, " "), w));
+        this.n = ls.length;
+        return ls.map((l) => "\x1b[2K" + l + "\n").join("");
+    }
+    clear() {
+        return this.n ? `\x1b[${this.n}A\x1b[J` : "";
+    }
+    start() {
+        if (!this.out.isTTY || this.up)
+            return this;
+        this.up = true;
+        this.out.write(this.paint());
+        this.timer = setInterval(() => this.out.write(this.clear() + this.paint()), 1000);
+        this.timer.unref?.();
+        return this;
+    }
+    log(line) {
+        if (!this.up)
+            return void this.out.write(line + "\n");
+        this.out.write(this.clear() + line + "\n" + this.paint());
+    }
+    stop() {
+        if (this.timer)
+            clearInterval(this.timer);
+        if (this.up)
+            this.out.write(this.clear());
+        this.up = false;
+        this.n = 0;
+    }
+}
+//# sourceMappingURL=term.js.map

package/dist/ui/watch.js

@@ -0,0 +1,271 @@
+// `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.
+ * 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: `${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: `${C.faint(`${p.pct}%`)}  ${clip(p.note)}` };
+        case "plan.announced":
+            return { agent: who, text: `${C.faint("plans:")} ${clip(p.summary ?? p.plan ?? p.intent ?? p.title)}` };
+        case "run.review":
+            return { agent: who, text: `${C.violet("◎")} reviewing ${p.author}'s “${clip(p.title, 60)}”` };
+        case "run.reviewed":
+            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: `${C.green("✓ merged")} ${clip(p.title, 80)}` };
+        case "run.failed":
+            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": {
+            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: `${C.faint("proposes:")} ${clip(p.text)}` };
+        case "council.critique":
+            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: `${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.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: `${C.violet("◎")} QA round ${p.round} · ${(p.agents ?? []).join(", ")}` };
+        case "qa.bug":
+            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: `${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: `${C.yellow("⤳")} ${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);
+        // 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")
+                a.tasks++;
+            if (e.type === "run.reviewed")
+                a.reviews++;
+            a.tokens += Number(p.tokens) || 0;
+        }
+    }
+    // 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 };
+}
+/**
+ * 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",
+    });
+    let seen = 0; // events come back ordered by (ts, rowid), so new ones are a suffix
+    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);
+            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 = events.length;
+    };
+    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) => {
+        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,65 @@
 {
   "name": "huddle-cli",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.1",
+  "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",
+    "QUICKSTART.md",
+    "CHANGELOG.md",
+    "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": "node scripts/test.mjs",
+    "e2e": "npm run build && node scripts/test.mjs e2e",
+    "evolve": "npm run build && node scripts/test.mjs evolve"
+  },
+  "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"
+  }
+}