@phren/agent 0.1.2 → 0.1.4

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 = "";
+    }
+}

package/dist/multi/spawner.js

@@ -28,6 +28,7 @@ const ENV_FORWARD_KEYS = [
     "PHREN_PROFILE",
     "PHREN_DEBUG",
     "HOME",
+    "USERPROFILE",
     "PATH",
     "NODE_EXTRA_CA_CERTS",
 ];
@@ -160,7 +161,7 @@ export class AgentSpawner extends EventEmitter {
         // Give it a moment to clean up, then force kill
         setTimeout(() => {
             if (this.processes.has(agentId)) {
-                child.kill("SIGTERM");
+                child.kill();
             }
         }, 5000);
         const agent = this.agents.get(agentId);
@@ -207,7 +208,7 @@ export class AgentSpawner extends EventEmitter {
                 setTimeout(() => {
                     // Force kill remaining
                     for (const [id, child] of this.processes) {
-                        child.kill("SIGKILL");
+                        child.kill();
                         this.processes.delete(id);
                     }
                     resolve();