@robzilla1738/agentswarm 0.2.0

package/dist/state.js

@@ -0,0 +1,230 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RunState = void 0;
+const types_1 = require("./types");
+/**
+ * Pure reducer over the journal. Both the live executor and the read-only hub
+ * build identical state from the same events — the journal is the truth.
+ */
+class RunState {
+    meta = null;
+    status = "planning";
+    statusReason = "";
+    tasks = new Map();
+    taskOrder = [];
+    agents = new Map();
+    notes = [];
+    conductorLog = [];
+    operatorNotes = [];
+    usageByModel = new Map();
+    totalUsage = { ...types_1.ZERO_USAGE };
+    cost = 0;
+    finalSummary;
+    finalReportPath;
+    lastSeq = 0;
+    lastT = 0;
+    createdAt = 0;
+    updatedAt = 0;
+    pricing;
+    constructor(pricing = {}) {
+        this.pricing = pricing;
+    }
+    apply(ev) {
+        this.lastSeq = ev.seq;
+        this.lastT = ev.t;
+        this.updatedAt = ev.t;
+        switch (ev.type) {
+            case "run.created": {
+                this.meta = ev.meta;
+                this.createdAt = this.meta.createdAt;
+                if (this.meta.options) {
+                    // pricing may be passed through meta for the hub
+                }
+                break;
+            }
+            case "run.status":
+                this.status = ev.status;
+                if (ev.reason)
+                    this.statusReason = String(ev.reason);
+                break;
+            case "run.resumed": {
+                // Tasks that were in flight when the engine died re-run from scratch;
+                // agents the dead process owned can no longer be running.
+                const resets = Array.isArray(ev.resets) ? ev.resets : [];
+                for (const id of resets) {
+                    const t = this.tasks.get(id);
+                    if (t) {
+                        t.status = "pending";
+                        t.startedAt = undefined;
+                        t.endedAt = undefined;
+                    }
+                }
+                for (const a of this.agents.values()) {
+                    if (a.status === "running") {
+                        a.status = "done";
+                        a.endedAt = ev.t;
+                    }
+                }
+                this.statusReason = "";
+                break;
+            }
+            case "task.created": {
+                const t = ev.task;
+                if (!this.tasks.has(t.id))
+                    this.taskOrder.push(t.id);
+                this.tasks.set(t.id, { ...t });
+                break;
+            }
+            case "task.status": {
+                const t = this.tasks.get(ev.taskId);
+                if (t) {
+                    t.status = ev.status;
+                    if (typeof ev.attempt === "number")
+                        t.attempt = ev.attempt;
+                    if (ev.status === "running" && !t.startedAt)
+                        t.startedAt = ev.t;
+                    if (["done", "failed", "blocked"].includes(String(ev.status)))
+                        t.endedAt = ev.t;
+                    if (ev.reason)
+                        t.error = String(ev.reason);
+                }
+                break;
+            }
+            case "task.report": {
+                const t = this.tasks.get(ev.taskId);
+                if (t) {
+                    t.report = ev.report;
+                    t.reportStatus = ev.status;
+                    t.artifacts = ev.artifacts ?? t.artifacts;
+                }
+                break;
+            }
+            case "verify.result": {
+                const t = this.tasks.get(ev.taskId);
+                if (t)
+                    t.feedback = ev.feedback;
+                break;
+            }
+            case "agent.spawned":
+                this.agents.set(ev.agentId, {
+                    id: ev.agentId,
+                    taskId: ev.taskId,
+                    role: ev.role ?? "agent",
+                    model: ev.model ?? "",
+                    purpose: ev.purpose ?? "",
+                    status: "running",
+                    steps: 0,
+                    startedAt: ev.t,
+                    lastText: "",
+                    lastThink: "",
+                });
+                break;
+            case "agent.delta": {
+                const a = this.agents.get(ev.agentId);
+                if (a) {
+                    if (ev.channel === "text")
+                        a.lastText = clipTail(a.lastText + ev.text, 4000);
+                    else
+                        a.lastThink = clipTail(a.lastThink + ev.text, 4000);
+                }
+                break;
+            }
+            case "agent.done": {
+                const a = this.agents.get(ev.agentId);
+                if (a) {
+                    a.status = "done";
+                    a.endedAt = ev.t;
+                    a.steps = ev.steps ?? a.steps;
+                }
+                break;
+            }
+            case "tool.call": {
+                const a = this.agents.get(ev.agentId);
+                if (a) {
+                    a.lastTool = ev.name;
+                    a.steps++;
+                }
+                break;
+            }
+            case "note.added":
+                this.notes.push({
+                    t: ev.t,
+                    taskId: ev.taskId,
+                    agentId: ev.agentId,
+                    key: ev.key,
+                    text: ev.text,
+                });
+                // Reduced state is held live by the hub and the resume seed — keep
+                // only the tail that digests/views actually use.
+                if (this.notes.length > 1000)
+                    this.notes.splice(0, this.notes.length - 1000);
+                break;
+            case "conductor.say":
+                this.conductorLog.push({ t: ev.t, text: ev.text });
+                if (this.conductorLog.length > 300)
+                    this.conductorLog.splice(0, this.conductorLog.length - 300);
+                break;
+            case "operator.note":
+                this.operatorNotes.push({ t: ev.t, text: ev.text, consumed: false });
+                break;
+            case "operator.note.consumed": {
+                const idx = this.operatorNotes.findIndex((n) => !n.consumed);
+                if (idx >= 0)
+                    this.operatorNotes[idx].consumed = true;
+                break;
+            }
+            case "usage": {
+                const u = ev.usage;
+                const model = ev.model ?? "unknown";
+                this.usageByModel.set(model, (0, types_1.addUsage)(this.usageByModel.get(model) ?? { ...types_1.ZERO_USAGE }, u));
+                this.totalUsage = (0, types_1.addUsage)(this.totalUsage, u);
+                this.cost += (0, types_1.usageCost)(u, this.pricing[model]);
+                break;
+            }
+            case "run.final":
+                this.finalSummary = ev.summary;
+                this.finalReportPath = ev.reportPath;
+                break;
+        }
+    }
+    taskList() {
+        return this.taskOrder.map((id) => this.tasks.get(id)).filter(Boolean);
+    }
+    activeAgents() {
+        return [...this.agents.values()].filter((a) => a.status === "running");
+    }
+    pendingOperatorNotes() {
+        return this.operatorNotes.filter((n) => !n.consumed).map((n) => n.text);
+    }
+    summary() {
+        const tasks = this.taskList();
+        const count = (s) => tasks.filter((t) => t.status === s).length;
+        return {
+            id: this.meta?.id ?? "",
+            mission: this.meta?.mission ?? "",
+            status: this.status,
+            statusReason: this.statusReason || undefined,
+            createdAt: this.createdAt,
+            updatedAt: this.updatedAt,
+            heartbeatAt: this.lastT,
+            pid: null,
+            model: this.meta?.options.model ?? "",
+            tasks: {
+                total: tasks.length,
+                done: count("done"),
+                failed: count("failed"),
+                running: count("running") + count("verifying"),
+                pending: count("pending"),
+                blocked: count("blocked"),
+            },
+            agentsActive: this.activeAgents().length,
+            usage: this.totalUsage,
+            cost: this.cost,
+            finalSummary: this.finalSummary,
+        };
+    }
+}
+exports.RunState = RunState;
+function clipTail(s, max) {
+    return s.length <= max ? s : s.slice(s.length - max);
+}

package/dist/terminal.js

@@ -0,0 +1,298 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TerminalRenderer = void 0;
+exports.watchRun = watchRun;
+const journal_1 = require("./journal");
+const config_1 = require("./config");
+const state_1 = require("./state");
+const util_1 = require("./util");
+const STATUS_STYLE = {
+    pending: util_1.ansi.gray,
+    running: util_1.ansi.cyan,
+    verifying: util_1.ansi.magenta,
+    done: util_1.ansi.green,
+    failed: util_1.ansi.red,
+    blocked: util_1.ansi.yellow,
+};
+const SPINNER = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+class TerminalRenderer {
+    state;
+    frame = 0;
+    timer = null;
+    active = false;
+    tty;
+    height = 40;
+    width = 100;
+    constructor(pricing) {
+        this.state = new state_1.RunState(pricing);
+        this.tty = Boolean(process.stdout.isTTY);
+    }
+    ingest(ev) {
+        this.state.apply(ev);
+        if (!this.tty)
+            this.streamLine(ev);
+    }
+    start() {
+        if (!this.tty) {
+            process.stdout.write("agentswarm: streaming (no TTY)\n");
+            return;
+        }
+        this.active = true;
+        process.stdout.write("\x1b[?25l"); // hide cursor
+        this.timer = setInterval(() => this.render(), 250);
+    }
+    stop() {
+        if (this.timer)
+            clearInterval(this.timer);
+        this.timer = null;
+        if (this.tty && this.active) {
+            this.render();
+            process.stdout.write("\x1b[?25h"); // show cursor
+        }
+        this.active = false;
+    }
+    getState() {
+        return this.state;
+    }
+    // ---------- non-tty streaming ----------
+    streamLine(ev) {
+        let line = "";
+        switch (ev.type) {
+            case "run.status":
+                line = `[run] ${ev.status}${ev.reason ? ` — ${ev.reason}` : ""}`;
+                break;
+            case "task.created":
+                line = `[task+] ${ev.task.id} ${ev.task.title}`;
+                break;
+            case "task.status":
+                line = `[task] ${ev.taskId} → ${ev.status}${ev.reason ? ` (${(0, util_1.oneLine)(String(ev.reason), 80)})` : ""}`;
+                break;
+            case "agent.spawned":
+                line = `[agent+] ${ev.agentId} (${ev.role}) ${(0, util_1.oneLine)(String(ev.purpose ?? ""), 60)}`;
+                break;
+            case "tool.call":
+                line = `  ${ev.agentId} · ${ev.name}`;
+                break;
+            case "conductor.action":
+                line = `[conductor] ${ev.kind}`;
+                break;
+            case "note.added":
+                line = `[note] ${(0, util_1.oneLine)(String(ev.text), 100)}`;
+                break;
+            case "operator.note":
+                line = `[operator] ${(0, util_1.oneLine)(String(ev.text), 100)}`;
+                break;
+            case "run.final":
+                line = `[final] ${(0, util_1.oneLine)(String(ev.summary), 200)}`;
+                break;
+            case "log":
+                if (ev.level !== "info")
+                    line = `[${ev.level}] ${ev.msg}`;
+                break;
+        }
+        if (line)
+            process.stdout.write(line + "\n");
+    }
+    // ---------- tty dashboard ----------
+    render() {
+        if (!this.tty)
+            return;
+        this.frame++;
+        this.height = process.stdout.rows || 40;
+        this.width = Math.min(process.stdout.columns || 100, 120);
+        const lines = this.compose();
+        const clipped = lines.slice(0, this.height - 1);
+        let out = "\x1b[H"; // cursor home
+        out += clipped.map((l) => l + "\x1b[K").join("\n"); // each line clears to EOL
+        out += "\x1b[J"; // clear below
+        process.stdout.write(out);
+    }
+    compose() {
+        const s = this.state;
+        const spin = SPINNER[this.frame % SPINNER.length];
+        const L = [];
+        const W = this.width;
+        const live = ["planning", "running", "synthesizing"].includes(s.status);
+        const statusIcon = live ? util_1.ansi.cyan(spin) : s.status === "done" ? util_1.ansi.green("●") : util_1.ansi.red("●");
+        L.push(`${statusIcon} ${util_1.ansi.bold("agentswarm")} ${util_1.ansi.gray("·")} ${statusColor(s.status)} ${util_1.ansi.gray("·")} ${util_1.ansi.gray(s.meta?.id ?? "")}`);
+        L.push(util_1.ansi.gray("  mission: ") + (0, util_1.clip)((0, util_1.oneLine)(s.meta?.mission ?? "", W - 12), W - 12));
+        // budget bar
+        const cap = s.meta?.options.maxTokens ?? 1;
+        const pct = Math.min(100, Math.round((s.totalUsage.promptTokens + s.totalUsage.completionTokens) / cap * 100));
+        const barW = Math.max(10, Math.min(40, W - 50));
+        const filled = Math.round((pct / 100) * barW);
+        const bar = util_1.ansi.cyan("█".repeat(filled)) + util_1.ansi.gray("░".repeat(barW - filled));
+        const spent = s.totalUsage.promptTokens + s.totalUsage.completionTokens;
+        L.push(`  ${bar} ${pct}%  ${util_1.ansi.gray((0, util_1.fmtTokens)(spent) + "/" + (0, util_1.fmtTokens)(cap) + " tok")}  ${util_1.ansi.green((0, util_1.fmtMoney)(s.cost))}`);
+        const tasks = s.taskList();
+        const counts = {
+            done: tasks.filter((t) => t.status === "done").length,
+            running: tasks.filter((t) => t.status === "running" || t.status === "verifying").length,
+            pending: tasks.filter((t) => t.status === "pending").length,
+            failed: tasks.filter((t) => t.status === "failed").length,
+            blocked: tasks.filter((t) => t.status === "blocked").length,
+        };
+        L.push(util_1.ansi.gray("  ") +
+            `${util_1.ansi.green(counts.done + " done")}  ${util_1.ansi.cyan(counts.running + " running")}  ${util_1.ansi.gray(counts.pending + " pending")}  ${counts.failed ? util_1.ansi.red(counts.failed + " failed") : util_1.ansi.gray("0 failed")}  ${counts.blocked ? util_1.ansi.yellow(counts.blocked + " blocked") : util_1.ansi.gray("0 blocked")}`);
+        L.push("");
+        // active agents
+        const agents = s.activeAgents();
+        if (agents.length) {
+            L.push(util_1.ansi.bold(`  Active agents (${agents.length})`));
+            for (const a of agents.slice(0, 8)) {
+                L.push(this.agentLine(a, spin, W));
+            }
+            if (agents.length > 8)
+                L.push(util_1.ansi.gray(`    …and ${agents.length - 8} more`));
+            L.push("");
+        }
+        // task table
+        L.push(util_1.ansi.bold("  Tasks"));
+        const visibleTasks = this.pickTasks(tasks, Math.max(6, this.height - L.length - 10));
+        for (const t of visibleTasks) {
+            L.push(this.taskLine(t, spin, W));
+        }
+        if (tasks.length > visibleTasks.length) {
+            L.push(util_1.ansi.gray(`    …${tasks.length - visibleTasks.length} more tasks`));
+        }
+        // conductor latest
+        const lastSay = s.conductorLog[s.conductorLog.length - 1];
+        if (lastSay) {
+            L.push("");
+            L.push(util_1.ansi.bold("  Conductor"));
+            for (const ln of wrap((0, util_1.oneLine)(lastSay.text, 600), W - 6).slice(0, 3)) {
+                L.push(util_1.ansi.gray("    ") + util_1.ansi.italic(ln));
+            }
+        }
+        // notes
+        if (s.notes.length) {
+            L.push("");
+            L.push(util_1.ansi.bold(`  Blackboard (${s.notes.length})`));
+            for (const n of s.notes.slice(-3)) {
+                L.push(util_1.ansi.gray("    • ") + (0, util_1.clip)((0, util_1.oneLine)((n.key ? `[${n.key}] ` : "") + n.text, W - 8), W - 8));
+            }
+        }
+        // operator hint
+        if (live) {
+            L.push("");
+            L.push(util_1.ansi.gray("  Ctrl-C to detach (run keeps going) · ") + util_1.ansi.gray(`swarm note ${s.meta?.id} "…" to steer · swarm cancel ${s.meta?.id}`));
+        }
+        else if (s.finalSummary) {
+            L.push("");
+            L.push(util_1.ansi.bold(util_1.ansi.green("  ✓ Final summary")));
+            for (const ln of wrap(s.finalSummary, W - 6).slice(0, 6))
+                L.push("    " + ln);
+            if (s.finalReportPath)
+                L.push(util_1.ansi.gray("    report: ") + s.finalReportPath);
+        }
+        return L;
+    }
+    agentLine(a, spin, W) {
+        const role = util_1.ansi.magenta(`${a.role}`);
+        const head = `    ${util_1.ansi.cyan(spin)} ${util_1.ansi.gray(a.taskId)} ${role} ${util_1.ansi.gray("·")} `;
+        const tool = a.lastTool ? util_1.ansi.yellow(a.lastTool) + " " : "";
+        const txt = (0, util_1.oneLine)(a.lastText || a.lastThink || a.purpose, W - 40);
+        return (0, util_1.clip)(head + tool + util_1.ansi.gray(txt), W + 40); // +40 accounts for ansi codes roughly
+    }
+    taskLine(t, spin, W) {
+        const style = STATUS_STYLE[t.status] ?? util_1.ansi.white;
+        const icon = t.status === "running" || t.status === "verifying"
+            ? util_1.ansi.cyan(spin)
+            : t.status === "done"
+                ? util_1.ansi.green("✓")
+                : t.status === "failed"
+                    ? util_1.ansi.red("✗")
+                    : t.status === "blocked"
+                        ? util_1.ansi.yellow("⊘")
+                        : util_1.ansi.gray("○");
+        const id = style(t.id.padEnd(4));
+        const role = util_1.ansi.gray(`(${t.role})`);
+        const deps = t.deps.length ? util_1.ansi.gray(` ⇠${t.deps.join(",")}`) : "";
+        const v = t.verify ? util_1.ansi.magenta(" ⊛") : "";
+        const dur = t.startedAt ? util_1.ansi.gray(" " + (0, util_1.fmtDur)((t.endedAt ?? Date.now()) - t.startedAt)) : "";
+        const title = (0, util_1.clip)(t.title, Math.max(20, W - 38));
+        return `    ${icon} ${id} ${title} ${role}${deps}${v}${dur}`;
+    }
+    pickTasks(tasks, budget) {
+        if (tasks.length <= budget)
+            return tasks;
+        // Prioritize active + recently settled.
+        const active = tasks.filter((t) => ["running", "verifying", "pending"].includes(t.status));
+        const settled = tasks.filter((t) => ["done", "failed", "blocked"].includes(t.status));
+        const keepSettled = Math.max(0, budget - active.length);
+        return [...settled.slice(-keepSettled), ...active].slice(-budget);
+    }
+}
+exports.TerminalRenderer = TerminalRenderer;
+function statusColor(s) {
+    switch (s) {
+        case "done":
+            return util_1.ansi.green(util_1.ansi.bold("done"));
+        case "failed":
+            return util_1.ansi.red(util_1.ansi.bold("failed"));
+        case "cancelled":
+            return util_1.ansi.yellow("cancelled");
+        case "synthesizing":
+            return util_1.ansi.magenta("synthesizing");
+        case "running":
+            return util_1.ansi.cyan("running");
+        case "planning":
+            return util_1.ansi.cyan("planning");
+        default:
+            return s;
+    }
+}
+function wrap(text, width) {
+    const words = text.split(/\s+/);
+    const lines = [];
+    let cur = "";
+    for (const w of words) {
+        if ((cur + " " + w).trim().length > width) {
+            if (cur)
+                lines.push(cur);
+            cur = w;
+        }
+        else {
+            cur = (cur + " " + w).trim();
+        }
+    }
+    if (cur)
+        lines.push(cur);
+    return lines;
+}
+/** Tail a run's journal into a renderer until it goes terminal (for `watch`). */
+async function watchRun(id, pricing) {
+    const renderer = new TerminalRenderer(pricing);
+    const file = (0, journal_1.eventsFile)((0, config_1.runDir)(id));
+    const tail = { offset: 0, carry: "" };
+    renderer.start();
+    return new Promise((resolve) => {
+        const tick = () => {
+            let evs = [];
+            try {
+                evs = (0, journal_1.readNewEvents)(file, tail);
+            }
+            catch {
+                /* file not ready */
+            }
+            for (const ev of evs)
+                renderer.ingest(ev);
+            const st = renderer.getState().status;
+            if (["done", "failed", "cancelled"].includes(st)) {
+                setTimeout(() => {
+                    // one last drain
+                    try {
+                        for (const ev of (0, journal_1.readNewEvents)(file, tail))
+                            renderer.ingest(ev);
+                    }
+                    catch { /* ignore */ }
+                    renderer.stop();
+                    resolve();
+                }, 500);
+                return;
+            }
+            setTimeout(tick, 300);
+        };
+        tick();
+    });
+}