@phren/agent 0.1.3 → 0.1.5

package/dist/index.js

@@ -184,12 +184,17 @@ export async function runAgentCli(raw) {
         mcpCleanup?.();
         return;
     }
-    // Interactive mode — TUI if terminal, fallback to REPL if not
+    // Interactive mode — Ink TUI if available, legacy TUI fallback, REPL if not TTY
     if (args.interactive) {
         const isTTY = process.stdout.isTTY && process.stdin.isTTY;
-        const session = isTTY
-            ? await (await import("./tui.js")).startTui(agentConfig)
-            : await (await import("./repl.js")).startRepl(agentConfig);
+        let session;
+        if (!isTTY) {
+            session = await (await import("./repl.js")).startRepl(agentConfig);
+        }
+        else {
+            // Ink TUI only — no legacy fallback
+            session = await (await import("./tui/ink-entry.js")).startInkTui(agentConfig);
+        }
         // Flush anti-patterns at session end
         if (phrenCtx) {
             try {

package/dist/mcp-client.js

@@ -24,7 +24,8 @@ class McpConnection {
             try {
                 const msg = JSON.parse(line);
                 if (msg.id !== undefined && this.pending.has(msg.id)) {
-                    const { resolve, reject } = this.pending.get(msg.id);
+                    const { resolve, reject, timer } = this.pending.get(msg.id);
+                    clearTimeout(timer);
                     this.pending.delete(msg.id);
                     if (msg.error)
                         reject(new Error(`MCP error: ${msg.error.message}`));
@@ -35,8 +36,10 @@ class McpConnection {
             catch { /* ignore non-JSON lines */ }
         });
         this.proc.on("error", (err) => {
-            for (const { reject } of this.pending.values())
+            for (const { reject, timer } of this.pending.values()) {
+                clearTimeout(timer);
                 reject(err);
+            }
             this.pending.clear();
         });
     }
@@ -44,15 +47,14 @@ class McpConnection {
         return new Promise((resolve, reject) => {
             const id = this.nextId++;
             const msg = { jsonrpc: "2.0", id, method, params };
-            this.pending.set(id, { resolve, reject });
-            this.proc.stdin.write(JSON.stringify(msg) + "\n");
-            // Timeout after 30s
-            setTimeout(() => {
+            const timer = setTimeout(() => {
                 if (this.pending.has(id)) {
                     this.pending.delete(id);
                     reject(new Error(`MCP call ${method} timed out (30s)`));
                 }
             }, 30_000);
+            this.pending.set(id, { resolve, reject, timer });
+            this.proc.stdin.write(JSON.stringify(msg) + "\n");
         });
     }
     async initialize() {
@@ -81,8 +83,10 @@ class McpConnection {
         }
         catch { /* ignore */ }
         this.rl.close();
-        for (const { reject } of this.pending.values())
+        for (const { reject, timer } of this.pending.values()) {
+            clearTimeout(timer);
             reject(new Error("Connection closed"));
+        }
         this.pending.clear();
     }
 }

package/dist/multi/multi-commands.js

@@ -0,0 +1,170 @@
+import { createPane, appendToPane, flushPartial } from "./pane.js";
+import { s, statusColor } from "./multi-render.js";
+function resolveAgentTarget(target, agentOrder, panes, spawner) {
+    // Try numeric index (1-based)
+    const idx = parseInt(target, 10);
+    if (!isNaN(idx) && idx >= 1 && idx <= agentOrder.length) {
+        return agentOrder[idx - 1];
+    }
+    // Try name match
+    for (const [id, pane] of panes) {
+        if (pane.name === target)
+            return id;
+    }
+    // Try agent ID
+    if (spawner.getAgent(target))
+        return target;
+    return null;
+}
+function appendToSystem(ctx, text) {
+    if (!ctx.selectedId || !ctx.panes.has(ctx.selectedId)) {
+        // Create a virtual system pane
+        const pane = createPane("_system", "system");
+        ctx.panes.set("_system", pane);
+        if (!ctx.agentOrder.includes("_system"))
+            ctx.agentOrder.push("_system");
+        ctx.setSelectedId("_system");
+        appendToPane(pane, text + "\n");
+    }
+    else {
+        const pane = ctx.panes.get(ctx.selectedId);
+        flushPartial(pane);
+        appendToPane(pane, text + "\n");
+    }
+    ctx.render();
+}
+export function handleSlashCommand(line, ctx) {
+    const parts = line.split(/\s+/);
+    const cmd = parts[0].toLowerCase();
+    if (cmd === "/spawn") {
+        const name = parts[1];
+        const task = parts.slice(2).join(" ");
+        if (!name || !task) {
+            appendToSystem(ctx, "Usage: /spawn <name> <task>");
+            return true;
+        }
+        const opts = {
+            task,
+            cwd: process.cwd(),
+            provider: ctx.config.provider.name,
+            permissions: "auto-confirm",
+            verbose: ctx.config.verbose,
+        };
+        const agentId = ctx.spawner.spawn(opts);
+        const pane = ctx.getOrCreatePane(agentId);
+        pane.name = name;
+        appendToPane(pane, s.cyan(`Spawned agent "${name}" (${agentId}): ${task}`) + "\n");
+        ctx.setSelectedId(agentId);
+        ctx.render();
+        return true;
+    }
+    if (cmd === "/list") {
+        const agents = ctx.spawner.listAgents();
+        if (agents.length === 0) {
+            appendToSystem(ctx, "No agents.");
+        }
+        else {
+            const lines = ["Agents:"];
+            for (let i = 0; i < agents.length; i++) {
+                const a = agents[i];
+                const pane = ctx.panes.get(a.id);
+                const name = pane?.name ?? a.id;
+                const color = statusColor(a.status);
+                const elapsed = a.finishedAt
+                    ? `${((a.finishedAt - a.startedAt) / 1000).toFixed(1)}s`
+                    : `${((Date.now() - a.startedAt) / 1000).toFixed(0)}s`;
+                lines.push(`  ${i + 1}. ${name} [${color(a.status)}] ${s.dim(elapsed)} — ${a.task.slice(0, 50)}`);
+            }
+            appendToSystem(ctx, lines.join("\n"));
+        }
+        return true;
+    }
+    if (cmd === "/kill") {
+        const target = parts[1];
+        if (!target) {
+            appendToSystem(ctx, "Usage: /kill <name|index>");
+            return true;
+        }
+        const agentId = resolveAgentTarget(target, ctx.agentOrder, ctx.panes, ctx.spawner);
+        if (!agentId) {
+            appendToSystem(ctx, `Agent "${target}" not found.`);
+            return true;
+        }
+        const ok = ctx.spawner.cancel(agentId);
+        const pane = ctx.getOrCreatePane(agentId);
+        if (ok) {
+            appendToPane(pane, s.yellow("\n--- Cancelled ---\n"));
+        }
+        else {
+            appendToSystem(ctx, `Agent "${target}" is not running.`);
+        }
+        ctx.render();
+        return true;
+    }
+    if (cmd === "/broadcast") {
+        const msg = parts.slice(1).join(" ");
+        if (!msg) {
+            appendToSystem(ctx, "Usage: /broadcast <message>");
+            return true;
+        }
+        const agents = ctx.spawner.listAgents();
+        let sent = 0;
+        for (const a of agents) {
+            if (a.status === "running") {
+                const pane = ctx.getOrCreatePane(a.id);
+                appendToPane(pane, s.yellow(`[broadcast] ${msg}`) + "\n");
+                sent++;
+            }
+        }
+        appendToSystem(ctx, `Broadcast sent to ${sent} running agent(s).`);
+        return true;
+    }
+    if (cmd === "/msg") {
+        const target = parts[1];
+        const msg = parts.slice(2).join(" ");
+        if (!target || !msg) {
+            appendToSystem(ctx, "Usage: /msg <agent> <text>");
+            return true;
+        }
+        const agentId = resolveAgentTarget(target, ctx.agentOrder, ctx.panes, ctx.spawner);
+        if (!agentId) {
+            appendToSystem(ctx, `Agent "${target}" not found.`);
+            return true;
+        }
+        const ok = ctx.spawner.sendToAgent(agentId, msg, "user");
+        if (ok) {
+            const recipientPane = ctx.getOrCreatePane(agentId);
+            flushPartial(recipientPane);
+            appendToPane(recipientPane, s.yellow(`[user -> ${recipientPane.name}] ${msg}`) + "\n");
+            if (ctx.selectedId && ctx.selectedId !== agentId && ctx.panes.has(ctx.selectedId)) {
+                const curPane = ctx.panes.get(ctx.selectedId);
+                flushPartial(curPane);
+                appendToPane(curPane, s.yellow(`[user -> ${recipientPane.name}] ${msg}`) + "\n");
+            }
+        }
+        else {
+            appendToSystem(ctx, `Agent "${target}" is not running.`);
+        }
+        ctx.render();
+        return true;
+    }
+    if (cmd === "/help") {
+        appendToSystem(ctx, [
+            "Commands:",
+            "  /spawn <name> <task>  — Spawn a new agent",
+            "  /list                 — List all agents",
+            "  /kill <name|index>    — Terminate an agent",
+            "  /msg <agent> <text>   — Send direct message to an agent",
+            "  /broadcast <msg>      — Send to all running agents",
+            "  /help                 — Show this help",
+            "",
+            "Keys:",
+            "  1-9                   — Select agent by number",
+            "  Ctrl+Left/Right       — Cycle agents",
+            "  PageUp/PageDown       — Scroll output",
+            "  Ctrl+D                — Exit (kills all)",
+        ].join("\n"));
+        return true;
+    }
+    return false;
+}

package/dist/multi/multi-events.js

@@ -0,0 +1,81 @@
+import { appendToPane, flushPartial } from "./pane.js";
+import { getAgentStyle } from "./agent-colors.js";
+import { decodeDiffPayload, renderInlineDiff, DIFF_MARKER } from "./diff-renderer.js";
+import { s, formatToolStart, formatToolEnd } from "./multi-render.js";
+export function wireSpawnerEvents(spawner, ctx) {
+    spawner.on("text_delta", (agentId, text) => {
+        const pane = ctx.getOrCreatePane(agentId);
+        appendToPane(pane, text);
+        if (agentId === ctx.getSelectedId())
+            ctx.render();
+    });
+    spawner.on("text_block", (agentId, text) => {
+        const pane = ctx.getOrCreatePane(agentId);
+        appendToPane(pane, text + "\n");
+        if (agentId === ctx.getSelectedId())
+            ctx.render();
+    });
+    spawner.on("tool_start", (agentId, toolName, input) => {
+        const pane = ctx.getOrCreatePane(agentId);
+        flushPartial(pane);
+        appendToPane(pane, formatToolStart(toolName, input) + "\n");
+        if (agentId === ctx.getSelectedId())
+            ctx.render();
+    });
+    spawner.on("tool_end", (agentId, toolName, input, output, isError, durationMs) => {
+        const pane = ctx.getOrCreatePane(agentId);
+        flushPartial(pane);
+        const diffData = (toolName === "edit_file" || toolName === "write_file") ? decodeDiffPayload(output) : null;
+        const cleanOutput = diffData ? output.slice(0, output.indexOf(DIFF_MARKER)) : output;
+        appendToPane(pane, formatToolEnd(toolName, input, cleanOutput, isError, durationMs) + "\n");
+        if (diffData) {
+            appendToPane(pane, renderInlineDiff(diffData.oldContent, diffData.newContent, diffData.filePath) + "\n");
+        }
+        if (agentId === ctx.getSelectedId())
+            ctx.render();
+    });
+    spawner.on("status", (agentId, message) => {
+        const pane = ctx.getOrCreatePane(agentId);
+        appendToPane(pane, s.dim(message) + "\n");
+        if (agentId === ctx.getSelectedId())
+            ctx.render();
+    });
+    spawner.on("done", (agentId, result) => {
+        const pane = ctx.getOrCreatePane(agentId);
+        flushPartial(pane);
+        const style = getAgentStyle(pane.index);
+        appendToPane(pane, "\n" + style.color(`--- ${style.icon} Agent completed ---`) + "\n");
+        appendToPane(pane, s.dim(`  Turns: ${result.turns}  Tool calls: ${result.toolCalls}${result.totalCost ? `  Cost: ${result.totalCost}` : ""}`) + "\n");
+        ctx.render();
+    });
+    spawner.on("error", (agentId, error) => {
+        const pane = ctx.getOrCreatePane(agentId);
+        flushPartial(pane);
+        const style = getAgentStyle(pane.index);
+        appendToPane(pane, "\n" + style.color(`--- ${style.icon} Error: ${error} ---`) + "\n");
+        ctx.render();
+    });
+    spawner.on("exit", (agentId, code) => {
+        const pane = ctx.getOrCreatePane(agentId);
+        if (code !== null && code !== 0) {
+            appendToPane(pane, s.dim(`  Process exited with code ${code}`) + "\n");
+        }
+        ctx.render();
+    });
+    spawner.on("message", (from, to, content) => {
+        const senderPane = ctx.panes.get(from);
+        if (senderPane) {
+            flushPartial(senderPane);
+            const toName = ctx.panes.get(to)?.name ?? to;
+            appendToPane(senderPane, s.yellow(`[${senderPane.name} -> ${toName}] ${content}`) + "\n");
+        }
+        const recipientPane = ctx.panes.get(to);
+        if (recipientPane) {
+            flushPartial(recipientPane);
+            const fromName = senderPane?.name ?? from;
+            appendToPane(recipientPane, s.yellow(`[${fromName} -> ${recipientPane.name}] ${content}`) + "\n");
+        }
+        if (from === ctx.getSelectedId() || to === ctx.getSelectedId())
+            ctx.render();
+    });
+}

package/dist/multi/multi-render.js

@@ -0,0 +1,146 @@
+import { getAgentStyle, formatAgentName } from "./agent-colors.js";
+// ── ANSI helpers (mirrors tui.ts pattern) ────────────────────────────────────
+export const ESC = "\x1b[";
+export const s = {
+    reset: `${ESC}0m`,
+    bold: (t) => `${ESC}1m${t}${ESC}0m`,
+    dim: (t) => `${ESC}2m${t}${ESC}0m`,
+    cyan: (t) => `${ESC}36m${t}${ESC}0m`,
+    green: (t) => `${ESC}32m${t}${ESC}0m`,
+    yellow: (t) => `${ESC}33m${t}${ESC}0m`,
+    red: (t) => `${ESC}31m${t}${ESC}0m`,
+    gray: (t) => `${ESC}90m${t}${ESC}0m`,
+    white: (t) => `${ESC}37m${t}${ESC}0m`,
+    bgGreen: (t) => `${ESC}42m${t}${ESC}0m`,
+    bgRed: (t) => `${ESC}41m${t}${ESC}0m`,
+    bgGray: (t) => `${ESC}100m${t}${ESC}0m`,
+    bgCyan: (t) => `${ESC}46m${t}${ESC}0m`,
+    bgYellow: (t) => `${ESC}43m${t}${ESC}0m`,
+    invert: (t) => `${ESC}7m${t}${ESC}0m`,
+};
+function stripAnsi(t) {
+    return t.replace(/\x1b\[[0-9;?]*[ -/]*[@-~]/g, "");
+}
+function cols() {
+    return process.stdout.columns || 80;
+}
+function rows() {
+    return process.stdout.rows || 24;
+}
+export function statusColor(status) {
+    switch (status) {
+        case "starting": return s.yellow;
+        case "running": return s.green;
+        case "done": return s.gray;
+        case "error": return s.red;
+        case "cancelled": return s.gray;
+    }
+}
+export function formatToolStart(toolName, input) {
+    const preview = JSON.stringify(input).slice(0, 60);
+    return s.dim(`  > ${toolName}(${preview})...`);
+}
+export function formatToolEnd(toolName, input, output, isError, durationMs) {
+    const dur = durationMs < 1000 ? `${durationMs}ms` : `${(durationMs / 1000).toFixed(1)}s`;
+    const icon = isError ? s.red("x") : s.green("ok");
+    const preview = JSON.stringify(input).slice(0, 50);
+    const header = s.dim(`  ${toolName}(${preview})`) + ` ${icon} ${s.dim(dur)}`;
+    const allLines = output.split("\n");
+    const w = cols();
+    const body = allLines.slice(0, 4).map((l) => s.dim(`  | ${l.slice(0, w - 6)}`)).join("\n");
+    const more = allLines.length > 4 ? `\n${s.dim(`  | ... (${allLines.length} lines)`)}` : "";
+    return `${header}\n${body}${more}`;
+}
+export function renderTopBar(spawner, panes, selectedId) {
+    const w_ = cols();
+    const agents = spawner.listAgents();
+    const tabs = [];
+    for (let i = 0; i < agents.length; i++) {
+        const a = agents[i];
+        const isSel = a.id === selectedId;
+        const pane = panes.get(a.id);
+        const paneIdx = pane?.index ?? i;
+        const stColor = statusColor(a.status);
+        const agentLabel = formatAgentName(pane?.name ?? a.task.slice(0, 12), paneIdx);
+        const statusTag = stColor(a.status);
+        const raw = ` ${i + 1}:${stripAnsi(agentLabel)} [${stripAnsi(statusTag)}] `;
+        const colored = ` ${i + 1}:${agentLabel} [${statusTag}] `;
+        const tab = isSel ? s.invert(raw) : colored;
+        tabs.push(tab);
+    }
+    if (agents.length === 0) {
+        tabs.push(s.dim(" no agents "));
+    }
+    const title = s.bold(" phren-multi ");
+    const tabStr = tabs.join(s.dim("|"));
+    const line = title + s.dim("|") + tabStr;
+    const pad = Math.max(0, w_ - stripAnsi(line).length);
+    return s.invert(stripAnsi(title)) + s.dim("|") + tabStr + " ".repeat(pad);
+}
+export function renderMainArea(panes, selectedId, scrollOffset) {
+    const availRows = rows() - 3; // top bar + bottom bar + input line
+    if (availRows < 1)
+        return [];
+    if (!selectedId || !panes.has(selectedId)) {
+        const emptyMsg = s.dim("  No agent selected. Use /spawn <name> <task> to create one.");
+        const lines = [emptyMsg];
+        while (lines.length < availRows)
+            lines.push("");
+        return lines;
+    }
+    const pane = panes.get(selectedId);
+    // Include partial line if any
+    const allLines = [...pane.lines];
+    if (pane.partial)
+        allLines.push(pane.partial);
+    // Apply scroll offset
+    const totalLines = allLines.length;
+    let start = Math.max(0, totalLines - availRows - scrollOffset);
+    let end = start + availRows;
+    if (end > totalLines) {
+        end = totalLines;
+        start = Math.max(0, end - availRows);
+    }
+    const visible = allLines.slice(start, end);
+    const w_ = cols();
+    const output = [];
+    const paneStyle = getAgentStyle(pane.index);
+    const linePrefix = paneStyle.color(paneStyle.icon) + " ";
+    const prefixLen = 2; // icon + space
+    for (const line of visible) {
+        output.push(linePrefix + line.slice(0, w_ - prefixLen));
+    }
+    // Pad remaining rows
+    while (output.length < availRows)
+        output.push("");
+    return output;
+}
+export function renderBottomBar(spawner) {
+    const w_ = cols();
+    const agentCount = spawner.listAgents().length;
+    const runningCount = spawner.getAgentsByStatus("running").length;
+    const left = ` Agents: ${agentCount} (${runningCount} running)`;
+    const right = `1-9:select  Ctrl+</>:cycle  /spawn /list /kill /broadcast  Ctrl+D:exit `;
+    const pad = Math.max(0, w_ - left.length - right.length);
+    return s.invert(left + " ".repeat(pad) + right);
+}
+export function render(w, spawner, panes, selectedId, scrollOffset, inputLine) {
+    // Hide cursor, move to top, clear screen
+    w.write(`${ESC}?25l${ESC}H${ESC}2J`);
+    // Top bar
+    w.write(renderTopBar(spawner, panes, selectedId));
+    w.write("\n");
+    // Main area
+    const mainLines = renderMainArea(panes, selectedId, scrollOffset);
+    for (const line of mainLines) {
+        w.write(line + "\n");
+    }
+    // Bottom bar
+    w.write(renderBottomBar(spawner));
+    w.write("\n");
+    // Input line
+    const prompt = s.cyan("multi> ");
+    w.write(prompt + inputLine);
+    // Show cursor
+    w.write(`${ESC}?25h`);
+}

package/dist/multi/pane.js

@@ -0,0 +1,28 @@
+export const MAX_SCROLLBACK = 1000;
+let nextPaneIndex = 0;
+export function resetPaneIndex() {
+    nextPaneIndex = 0;
+}
+export function createPane(agentId, name) {
+    return { agentId, name, index: nextPaneIndex++, lines: [], partial: "" };
+}
+export function appendToPane(pane, text) {
+    // Merge with partial line buffer
+    const combined = pane.partial + text;
+    const parts = combined.split("\n");
+    // Everything except the last segment is a complete line
+    for (let i = 0; i < parts.length - 1; i++) {
+        pane.lines.push(parts[i]);
+    }
+    pane.partial = parts[parts.length - 1];
+    // Enforce scrollback cap
+    if (pane.lines.length > MAX_SCROLLBACK) {
+        pane.lines.splice(0, pane.lines.length - MAX_SCROLLBACK);
+    }
+}
+export function flushPartial(pane) {
+    if (pane.partial) {
+        pane.lines.push(pane.partial);
+        pane.partial = "";
+    }
+}