huddle-cli 0.1.0 → 0.1.3

package/dist/ui/talk.js

@@ -0,0 +1,176 @@
+// You and the room, during a run: the agents' questions for you
+// (huddle_ask_user) and what you type to them.
+//
+// A question shows like the ones Claude Code, Codex and Cursor ask, with
+// numbered options, the agent's recommendation first:
+//
+//   ⚑ claude asks you · should it also convert Rankine?
+//     1. No, just C, F and K (recommended)
+//     2. Yes, add Rankine too
+//     type 1-2 · Enter = 1 · or answer in your own words · picks 1 in 90s
+//
+// Unanswered, it goes with option 1 when the time runs out: the run never
+// waits on someone who walked away. Anything else you type during a run goes
+// to every working agent, sent as "you" (room/user.ts); "@codex …" to one.
+import { fmtDuration } from "../adapters/usage.js";
+import { C } from "./term.js";
+export class Talk {
+    now;
+    queue = [];
+    /** A question is on screen (the first one asked; the rest wait their turn). */
+    onShow = () => { };
+    /** It was answered, by you or by the clock. */
+    onSettled = () => { };
+    /** Set by the run while it's on: what you typed for the agents, and `details`. */
+    say = null;
+    details = null;
+    constructor(now = () => Date.now()) {
+        this.now = now;
+    }
+    /** The question on screen and when it times out, if any. */
+    current() {
+        const p = this.queue[0];
+        return p ? { q: p.q, until: p.until } : null;
+    }
+    ask(q) {
+        return new Promise((resolve) => {
+            const p = { q, until: 0, settle: resolve, timer: undefined };
+            this.queue.push(p);
+            if (this.queue.length === 1)
+                this.show();
+        });
+    }
+    /** The time starts when a question reaches the screen, not when it was asked. */
+    show() {
+        const p = this.queue[0];
+        if (!p)
+            return;
+        p.until = this.now() + p.q.waitMs;
+        p.timer = setTimeout(() => this.settle({ choice: 1, text: "", by: "default" }), p.q.waitMs);
+        this.onShow(p.q, p.until);
+    }
+    settle(a) {
+        const p = this.queue.shift();
+        if (!p)
+            return;
+        clearTimeout(p.timer);
+        p.settle(a);
+        this.onSettled(p.q, a);
+        this.show();
+    }
+    /**
+     * A line you typed. With a question up, it's the answer: a number picks that
+     * option, Enter picks 1, anything else is your answer in your own words.
+     * Returns false when no question is up (the line is for someone else).
+     */
+    answer(line) {
+        const p = this.queue[0];
+        if (!p)
+            return false;
+        const t = line.trim();
+        const k = Number(t);
+        if (!t)
+            this.settle({ choice: 1, text: "", by: "you" });
+        else if (/^\d$/.test(t) && k >= 1 && k <= p.q.options.length)
+            this.settle({ choice: k, text: "", by: "you" });
+        else
+            this.settle({ choice: null, text: t, by: "you" });
+        return true;
+    }
+    /** Every open question goes with option 1 (the run ended or was stopped). */
+    close() {
+        while (this.queue.length)
+            this.settle({ choice: 1, text: "", by: "default" });
+    }
+}
+/** The question as it's printed. */
+export function questionLines(q, until, now = Date.now()) {
+    const out = [`  ${C.yellow("⚑")} ${C.bold(q.from)} ${C.yellow("asks you")} ${C.faint("·")} ${q.question}`];
+    if (q.why)
+        out.push(C.faint(`    ${q.why}`));
+    q.options.forEach((o, i) => out.push(`    ${C.bold(String(i + 1) + ".")} ${o}${i === 0 ? C.faint(" (recommended)") : ""}`));
+    out.push(C.faint(`    type 1-${q.options.length} · Enter = 1 · or answer in your own words · picks 1 in ${fmtDuration(Math.max(0, until - now))}`));
+    return out;
+}
+/** "  → you chose 2: Yes, add Rankine too" / "  → no answer in 1m30s: claude goes with 1: …" */
+export function settledLine(q, a) {
+    if (a.by === "default")
+        return C.faint(`    → no answer in ${fmtDuration(q.waitMs)}: ${q.from} goes with 1 · ${q.options[0]}`);
+    return `    ${C.green("→")} ${a.choice ? `you chose ${a.choice} · ${q.options[a.choice - 1]}` : `you said: ${a.text}`} ${C.faint(`· sent to ${q.from}`)}`;
+}
+/** "@codex use 2 decimals" → to codex; anything else → everyone working. */
+export function addressee(line) {
+    const m = /^@([\w#./-]+)[,:]?\s+([\s\S]+)$/.exec(line.trim());
+    return m ? { to: m[1], text: m[2].trim() } : { text: line.trim() };
+}
+/**
+ * A typing line under a one-shot run's pinned block (`huddle join` on a
+ * terminal), so you can answer questions and talk to the agents there too.
+ * Raw keys: Enter sends, Backspace and ctrl-u edit, ctrl-c stops the run.
+ */
+export class KeyLine {
+    onLine;
+    onChange;
+    onInterrupt;
+    input;
+    buf = "";
+    on = false;
+    onData = (d) => this.feed(String(d));
+    constructor(onLine, onChange, 
+    /** ctrl-c: raw mode keeps the terminal from sending SIGINT, so the run decides. */
+    onInterrupt = () => process.exit(130), input = process.stdin) {
+        this.onLine = onLine;
+        this.onChange = onChange;
+        this.onInterrupt = onInterrupt;
+        this.input = input;
+    }
+    start() {
+        if (this.on || !this.input.isTTY)
+            return this;
+        this.on = true;
+        this.input.setRawMode?.(true);
+        this.input.on("data", this.onData);
+        this.input.resume();
+        return this;
+    }
+    stop() {
+        if (!this.on)
+            return;
+        this.on = false;
+        this.input.off("data", this.onData);
+        this.input.setRawMode?.(false);
+        this.input.pause();
+    }
+    /** What the line shows: what you've typed so far, or how to use it. */
+    line() {
+        if (!this.on)
+            return "";
+        return this.buf
+            ? `  ${C.violet("›")} ${this.buf}${C.faint("▏")}`
+            : `  ${C.violet("›")} ${C.faint("type to talk to the agents (@claude for one) · details · ctrl-c stops")}`;
+    }
+    feed(s) {
+        // Arrows and other escape keys: not text.
+        for (const ch of s.replace(/\x1b\[[0-9;?]*[A-Za-z~]|\x1bO?./g, "")) {
+            if (ch === "\r" || ch === "\n") {
+                const l = this.buf;
+                this.buf = "";
+                this.onLine(l);
+            }
+            else if (ch === "\x7f" || ch === "\b")
+                this.buf = [...this.buf].slice(0, -1).join("");
+            else if (ch === "\x15")
+                this.buf = "";
+            else if (ch === "\x03") {
+                this.buf = "";
+                this.onInterrupt();
+                if (!this.on)
+                    return;
+            }
+            else if (ch >= " ")
+                this.buf += ch;
+        }
+        this.onChange();
+    }
+}
+//# sourceMappingURL=talk.js.map

package/dist/ui/term.js

@@ -1,6 +1,41 @@
 // 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);
@@ -33,9 +68,21 @@ export const AGENT_COLOR = {
 };
 /** 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). */
+/** 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) {
-    return [...s.replace(/\x1b\[[0-9;]*m/g, "")].length;
+    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) {
@@ -51,17 +98,71 @@ export function truncate(s, n) {
             continue;
         }
         const ch = String.fromCodePoint(s.codePointAt(i));
-        if (seen >= n - 1)
-            return out + "…\x1b[0m";
+        const w = cells(ch);
+        if (seen + w > n - 1)
+            return out + "…" + (out.includes("\x1b[") ? "\x1b[0m" : "");
         out += ch;
-        seen++;
+        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)));
 }
+/**
+ * Whether progress bars draw block characters. Off when colors are (NO_COLOR,
+ * or output piped to a log): there a bar is just its label, "6/9 tasks".
+ * Tests and samples flip it to see the bars.
+ */
+export const BARS = { on: color, ascii: ASCII };
+/**
+ * A progress bar exactly `w` cells wide — "█████░░░" — or "" when bars are off
+ * or there's no room (under 2 cells). `frac` null = unknown: a faint dotted
+ * track, never a made-up 0%. Anything above 0 shows at least one block and
+ * anything below 1 leaves at least one empty, so 1% isn't nothing and 99%
+ * isn't done. Legacy consoles get "#####...".
+ */
+export function bar(frac, w, o = {}) {
+    w = Math.floor(w);
+    if (!(o.on ?? BARS.on) || !(w >= 2))
+        return "";
+    const ascii = o.ascii ?? BARS.ascii;
+    const [full, empty, unknown] = ascii ? ["#", ".", "-"] : ["█", "░", "·"];
+    if (frac === null || !Number.isFinite(frac))
+        return C.faint(unknown.repeat(w));
+    const f = o.tone === "done" ? 1 : Math.min(1, Math.max(0, frac));
+    const n = f <= 0 ? 0 : f >= 1 ? w : Math.min(w - 1, Math.max(1, Math.round(f * w)));
+    const fill = o.tone === "done" ? C.green : o.tone === "failed" ? C.red : C.violet;
+    return (n ? fill(full.repeat(n)) : "") + (n < w ? C.faint(empty.repeat(w - n)) : "");
+}
 /** Rounded box with a colored border, Claude-Code style. */
 export function box(lines, opts = {}) {
     const border = opts.border ?? C.violet;
@@ -71,44 +172,109 @@ export function box(lines, opts = {}) {
     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. */
+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) {
+    constructor(render, out = process.stdout) {
         this.render = render;
+        this.out = out;
         this.lines = [];
     }
     start() {
         this.draw();
-        if (process.stdout.isTTY)
+        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 (!process.stdout.isTTY)
+        if (!this.out.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`);
+        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)
-            process.stdout.write("\x1b[2K" + l + "\n");
+            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 (!process.stdout.isTTY) {
+        if (!this.out.isTTY) {
             for (const l of this.render(" "))
-                process.stdout.write(l + "\n");
+                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;
+    }
+    /** Repaint now (something it shows changed, e.g. a key was typed). */
+    redraw() {
+        if (this.up)
+            this.out.write(this.clear() + this.paint());
+    }
+    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