@pi-archimedes/subagent 0.3.1

package/src/expanded.ts

@@ -0,0 +1,221 @@
+import { Text } from "@earendil-works/pi-tui";
+import type { SubagentDetails, SubagentProgress, SubagentResult } from "./types.js";
+import { formatTokens, formatDuration, truncLine, buildStatsLine } from "./format.js";
+
+type Theme = { fg: (token: string, text: string) => string; bold: (text: string) => string };
+
+// ── Expanded completed result ───────────────────────────────────────────────
+
+export function buildExpandedText(
+  result: SubagentResult,
+  progress: SubagentProgress | undefined,
+  theme: Theme,
+): string {
+  const lines: string[] = [];
+
+  // Stats line (same as compact view)
+  const modelName = progress?.model ?? result.model;
+  const modelLabel = modelName ? theme.fg("accent", modelName) : "";
+  const statsLine = buildStatsLine({
+    turns: result.usage.turns,
+    toolCount: result.progressSummary?.toolCount,
+    tokens: result.progressSummary?.tokens,
+    durationMs: result.progressSummary?.durationMs,
+    cost: result.usage.cost,
+  }, theme);
+  const expandHint = theme.fg("muted", "(ctrl+o)");
+  const statsParts = [modelLabel, statsLine, expandHint].filter(Boolean);
+  if (statsParts.length > 0) {
+    lines.push(statsParts.join(" "));
+  }
+
+  // Task
+  if (result.task) {
+    lines.push("");
+    lines.push(theme.fg("dim", "Task: " + result.task));
+  }
+
+  // Tool calls history
+  const toolCalls = progress?.toolCalls;
+  if (toolCalls && toolCalls.length > 0) {
+    lines.push("");
+    for (const call of toolCalls) {
+      lines.push(theme.fg("dim", "- " + call));
+    }
+  }
+
+  // Output - show live streaming output or final output
+  const outputText = progress?.output ?? result.finalOutput;
+  if (outputText) {
+    lines.push("");
+    lines.push(outputText);
+  }
+
+  // Error
+  if (result.error) {
+    lines.push("");
+    lines.push(theme.fg("error", "✗ " + result.error));
+  } else if (result.exitCode === 0) {
+    lines.push("");
+    lines.push(theme.fg("success", "✓ Done"));
+  } else {
+    lines.push("");
+    lines.push(theme.fg("error", "✗ Failed"));
+  }
+
+  return lines.join("\n");
+}
+
+export function renderExpanded(
+  text: Text,
+  result: SubagentResult,
+  progress: SubagentProgress | undefined,
+  theme: Theme,
+): Text {
+  text.setText(buildExpandedText(result, progress, theme));
+  return text;
+}
+
+// ── Expanded streaming progress ─────────────────────────────────────────────
+
+export function renderProgressExpanded(
+  text: Text,
+  progress: SubagentProgress,
+  theme: Theme,
+): Text {
+  const lines: string[] = [];
+
+  // Stats line (same as compact view)
+  const modelLabel = progress.model ? theme.fg("accent", progress.model) : "";
+  const statsLine = buildStatsLine({
+    toolCount: progress.toolCount,
+    tokens: progress.tokens,
+    durationMs: progress.durationMs,
+    cost: progress.cost,
+  }, theme);
+  const expandHint = theme.fg("muted", "(ctrl+o)");
+  const statsParts = [modelLabel, statsLine, expandHint].filter(Boolean);
+  if (statsParts.length > 0) {
+    lines.push(statsParts.join(" "));
+  }
+
+  // Task
+  if (progress.task) {
+    lines.push("");
+    lines.push(theme.fg("dim", "Task: " + progress.task));
+  }
+
+  // Tool calls history
+  if (progress.toolCalls && progress.toolCalls.length > 0) {
+    lines.push("");
+    for (const call of progress.toolCalls) {
+      lines.push(theme.fg("dim", "- " + call));
+    }
+  }
+
+  // Activity (current tool with spinner)
+  if (progress.currentTool) {
+    lines.push("");
+    const argsPreview = progress.currentToolArgs
+      ? truncLine(progress.currentToolArgs, 60)
+      : "";
+    const durationPart = progress.currentToolStartedAt
+      ? " | " + formatDuration(Date.now() - progress.currentToolStartedAt)
+      : "";
+    let line = theme.fg("syntaxFunction", progress.currentTool);
+    if (argsPreview) {
+      line += theme.fg("dim", ": " + argsPreview);
+    }
+    if (durationPart) {
+      line += theme.fg("dim", durationPart);
+    }
+    lines.push(line);
+  }
+
+  // Status at bottom
+  if (progress.status === "completed") {
+    lines.push("");
+    lines.push(theme.fg("success", "✓ Done"));
+  } else if (progress.status === "failed") {
+    lines.push("");
+    if (progress.error) {
+      lines.push(theme.fg("error", "✗ " + progress.error));
+    } else {
+      lines.push(theme.fg("error", "✗ Failed"));
+    }
+  }
+
+  text.setText(lines.join("\n"));
+  return text;
+}
+
+// ── Expanded parallel streaming progress ────────────────────────────────────
+
+export function buildProgressExpandedText(
+  progress: SubagentProgress,
+  theme: Theme,
+): string {
+  const lines: string[] = [];
+
+  // Stats line (same as compact view)
+  const modelLabel = progress.model ? theme.fg("accent", progress.model) : "";
+  const statsLine = buildStatsLine({
+    toolCount: progress.toolCount,
+    tokens: progress.tokens,
+    durationMs: progress.durationMs,
+    cost: progress.cost,
+  }, theme);
+  const expandHint = theme.fg("muted", "(ctrl+o)");
+  const statsParts = [modelLabel, statsLine, expandHint].filter(Boolean);
+  if (statsParts.length > 0) {
+    lines.push(statsParts.join(" "));
+  }
+
+  // Task
+  if (progress.task) {
+    lines.push("");
+    lines.push(theme.fg("dim", "Task: " + progress.task));
+  }
+
+  // Tool calls history
+  if (progress.toolCalls && progress.toolCalls.length > 0) {
+    lines.push("");
+    for (const call of progress.toolCalls) {
+      lines.push(theme.fg("dim", "- " + call));
+    }
+  }
+
+  // Activity
+  if (progress.currentTool) {
+    const argsPreview = progress.currentToolArgs
+      ? truncLine(progress.currentToolArgs, 60)
+      : "";
+    const durationPart = progress.currentToolStartedAt
+      ? " | " + formatDuration(Date.now() - progress.currentToolStartedAt)
+      : "";
+    let line = theme.fg("syntaxFunction", progress.currentTool);
+    if (argsPreview) {
+      line += theme.fg("dim", ": " + argsPreview);
+    }
+    if (durationPart) {
+      line += theme.fg("dim", durationPart);
+    }
+    lines.push("");
+    lines.push(line);
+  }
+
+  // Status at bottom
+  if (progress.status === "completed") {
+    lines.push("");
+    lines.push(theme.fg("success", "✓ Done"));
+  } else if (progress.status === "failed") {
+    lines.push("");
+    if (progress.error) {
+      lines.push(theme.fg("error", "✗ " + progress.error));
+    } else {
+      lines.push(theme.fg("error", "✗ Failed"));
+    }
+  }
+
+  return lines.join("\n");
+}

package/src/format.ts

@@ -0,0 +1,60 @@
+import { clampLine } from "@pi-archimedes/core/text";
+
+export const SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+
+export function formatTokens(n: number): string {
+  if (n >= 1_000_000) return (n / 1_000_000).toFixed(1) + "M";
+  if (n >= 1_000) return Math.round(n / 1_000) + "k";
+  return String(n);
+}
+
+export function formatDuration(ms: number): string {
+  if (ms < 1000) return "0s";
+  const seconds = Math.floor(ms / 1000);
+  if (seconds < 60) return seconds + "s";
+  const minutes = Math.floor(seconds / 60);
+  const remaining = seconds % 60;
+  return minutes + "m" + (remaining > 0 ? remaining + "s" : "");
+}
+
+export function formatCost(cost: number): string {
+  if (cost === 0) return "";
+  if (cost < 0.01) return "$" + cost.toFixed(4);
+  return "$" + cost.toFixed(2);
+}
+
+export function truncLine(text: string, width: number): string {
+  return clampLine(text, width);
+}
+
+export interface StatsData {
+  turns?: number;
+  toolCount?: number;
+  tokens?: number;
+  durationMs?: number;
+  cost?: number;
+}
+
+export interface StatsTheme {
+  fg: (token: string, text: string) => string;
+}
+
+export function buildStatsLine(
+  data: StatsData,
+  theme: StatsTheme,
+): string {
+  const parts: string[] = [];
+  const turns = data.turns ?? 0;
+  const tools = data.toolCount ?? 0;
+  const tokens = data.tokens ?? 0;
+  const duration = data.durationMs ?? 0;
+  const cost = data.cost ?? 0;
+
+  if (turns > 0) parts.push("⟳ " + turns);
+  if (tools > 0) parts.push(tools + " tool" + (tools !== 1 ? "s" : ""));
+  if (tokens > 0) parts.push(formatTokens(tokens) + " tok");
+  if (duration > 0) parts.push(formatDuration(duration));
+  if (cost > 0) parts.push(formatCost(cost));
+
+  return parts.map(p => theme.fg("dim", "· " + p)).join(" ");
+}

package/src/handlers.ts

@@ -0,0 +1,158 @@
+import type { StreamState } from "./types.js";
+
+export interface JsonEvent {
+  type: string;
+  [key: string]: unknown;
+}
+
+/**
+ * Extract a short args preview from tool arguments.
+ * Generic: no hardcoded tool names.
+ */
+export function extractArgsPreview(args: unknown): string {
+  if (typeof args === "string") return args.slice(0, 120);
+  if (args && typeof args === "object" && !Array.isArray(args)) {
+    const obj = args as Record<string, unknown>;
+    const keys = Object.keys(obj);
+    // Single-key object: just show the value
+    if (keys.length === 1) {
+      const v = obj[keys[0]];
+      if (typeof v === "string") return v.slice(0, 120);
+      if (typeof v === "number" || typeof v === "boolean") return String(v);
+    }
+    // Multi-key: find the longest string value (likely the main payload)
+    let best: string | undefined;
+    for (const v of Object.values(obj)) {
+      if (typeof v === "string" && v.length > (best?.length ?? 0)) {
+        best = v;
+      }
+    }
+    if (best) return best.slice(0, 120);
+  }
+  return JSON.stringify(args)?.slice(0, 120) ?? "";
+}
+
+/**
+ * Handle a tool_execution_start event.
+ */
+export function handleToolStart(state: StreamState, event: JsonEvent): void {
+  state.toolCount++;
+  state.currentTool = event.toolName as string;
+  state.currentToolArgs = JSON.stringify(event.args);
+  state.currentToolStartedAt = Date.now();
+  // Record tool call with args preview
+  const argsPreview = extractArgsPreview(event.args);
+  state.toolCalls.push(`${state.currentTool}: ${argsPreview}`);
+  if (state.toolCalls.length > 50) {
+    state.toolCalls.splice(0, state.toolCalls.length - 50);
+  }
+}
+
+/**
+ * Handle a tool_execution_end event.
+ */
+export function handleToolEnd(state: StreamState): void {
+  state.currentTool = undefined;
+  state.currentToolArgs = undefined;
+  state.currentToolStartedAt = undefined;
+}
+
+/**
+ * Handle a tool_result_end event — capture tool output for live display.
+ */
+export function handleToolResult(state: StreamState, event: JsonEvent): void {
+  const toolMessage = event.message as Record<string, unknown> | undefined;
+  if (!toolMessage || toolMessage.role !== "toolResult") return;
+
+  const toolContent = toolMessage.content as Array<Record<string, unknown>> | string | undefined;
+  const toolName = (toolMessage.toolName as string) ?? "tool";
+
+  if (typeof toolContent === "string" && toolContent.trim()) {
+    const lines = toolContent.split("\n").filter((l) => l.trim());
+    state.recentOutput.push(`[${toolName}] ${lines[0]?.slice(0, 120)}`);
+  } else if (Array.isArray(toolContent)) {
+    for (const part of toolContent) {
+      if (part.type === "text" && (part.text as string)?.trim()) {
+        const text = part.text as string;
+        const lines = text.split("\n").filter((l) => l.trim());
+        state.recentOutput.push(`[${toolName}] ${lines[0]?.slice(0, 120)}`);
+        break;
+      }
+    }
+  }
+
+  if (state.recentOutput.length > 50) {
+    state.recentOutput.splice(0, state.recentOutput.length - 50);
+  }
+}
+
+/**
+ * Handle a message_end event — extract usage and text from assistant messages.
+ */
+export function handleMessageEnd(state: StreamState, event: JsonEvent): void {
+  const message = event.message as Record<string, unknown> | undefined;
+  if (!message || message.role !== "assistant") return;
+
+  // Capture model name
+  if (!state.model && message.model) {
+    state.model = message.model as string;
+  }
+
+  // Collect text output
+  const content = message.content as Array<Record<string, unknown>> | string | undefined;
+  if (typeof content === "string" && content.trim()) {
+    state.accumulatedOutput.push(content);
+    const lines = content.split("\n").filter((l) => l.trim());
+    state.recentOutput.push(...lines.slice(-10));
+  } else if (Array.isArray(content)) {
+    for (const part of content) {
+      if (part.type === "text" && (part.text as string)?.trim()) {
+        const text = part.text as string;
+        state.accumulatedOutput.push(text);
+        const lines = text.split("\n").filter((l) => l.trim());
+        state.recentOutput.push(...lines.slice(-10));
+      }
+    }
+  }
+
+  // Cap recentOutput at 50 lines
+  if (state.recentOutput.length > 50) {
+    state.recentOutput.splice(0, state.recentOutput.length - 50);
+  }
+
+  // Extract usage (turnCount tracked via turn_start in stream.ts)
+  if (message.usage) {
+    const usage = message.usage as Record<string, unknown>;
+    state.totalInput += (usage.input as number) || 0;
+    state.totalOutput += (usage.output as number) || 0;
+    state.totalCacheRead += (usage.cacheRead as number) || 0;
+    state.totalCacheWrite += (usage.cacheWrite as number) || 0;
+    const costObj = usage.cost as { total?: number } | undefined;
+    state.totalCost += costObj?.total ?? 0;
+  }
+}
+
+/**
+ * Handle an agent_end event — collect all assistant text for final output.
+ */
+export function handleAgentEnd(state: StreamState, event: JsonEvent): void {
+  const messages = event.messages as Array<Record<string, unknown>> | undefined;
+  if (!messages || messages.length === 0) return;
+
+  const allText: string[] = [];
+  for (const msg of messages) {
+    if (msg.role === "assistant") {
+      const content = msg.content as Array<Record<string, unknown>> | string | undefined;
+      if (typeof content === "string" && content.trim()) {
+        allText.push(content);
+      } else if (Array.isArray(content)) {
+        for (const part of content) {
+          if (part.type === "text" && (part.text as string)?.trim()) {
+            allText.push(part.text as string);
+          }
+        }
+      }
+    }
+  }
+  state.finalOutput = allText.join("\n\n");
+}

package/src/index.ts

@@ -0,0 +1,224 @@
+import type { ExtensionAPI, ExtensionContext, Theme } from "@earendil-works/pi-coding-agent";
+import { Text } from "@earendil-works/pi-tui";
+import { Type } from "typebox";
+import { executeSubagent, executeParallel } from "./execute.js";
+import { renderSubagentResult } from "./render.js";
+import type {
+  SubagentDetails,
+  SubagentProgress,
+  SubagentResult,
+  SubagentToolResult,
+} from "./types.js";
+
+// ── JSON Schema for tool parameters (TypeBox) ──────────────────────────────
+
+const TaskItem = Type.Object({
+  agent: Type.Optional(Type.String()),
+  task: Type.String(),
+  count: Type.Optional(Type.Number()),
+  model: Type.Optional(Type.String()),
+  cwd: Type.Optional(Type.String()),
+});
+
+const SUBAGENT_PARAMS_SCHEMA = Type.Object({
+  agent: Type.Optional(Type.String({
+    description: "Agent name/identifier (optional, defaults to 'general')",
+  })),
+  task: Type.Optional(Type.String({
+    description: "Task description for the subagent",
+  })),
+  tasks: Type.Optional(Type.Array(TaskItem, {
+    description: "Multiple tasks for parallel execution",
+  })),
+  model: Type.Optional(Type.String({
+    description: "Model override (e.g. 'anthropic/claude-sonnet-4')",
+  })),
+  async: Type.Optional(Type.Boolean({
+    description: "Run asynchronously (fire-and-forget)",
+  })),
+  cwd: Type.Optional(Type.String({
+    description: "Working directory for the subagent",
+  })),
+});
+
+// ── Theme helper type for render functions ──────────────────────────────────
+
+interface RenderTheme {
+  fg: (token: string, text: string) => string;
+  bold: (text: string) => string;
+}
+
+// ── Tool registration ───────────────────────────────────────────────────────
+
+export function registerSubagent(pi: ExtensionAPI): void {
+  pi.registerTool({
+    name: "subagent",
+    label: "Subagent",
+    description:
+      "Delegate tasks to subagents. Single: { agent, task }. Parallel: { tasks: [{ agent, task }] }. Options: model, cwd.",
+    parameters: SUBAGENT_PARAMS_SCHEMA,
+
+    async execute(
+      _id: string,
+      params: {
+        agent?: string;
+        task?: string;
+        tasks?: Array<{ agent?: string; task: string; count?: number; model?: string; cwd?: string }>;
+        model?: string;
+        cwd?: string;
+        async?: boolean;
+      },
+      signal: AbortSignal | undefined,
+      onUpdate: ((update: SubagentToolResult) => void) | undefined,
+      _ctx: ExtensionContext,
+    ): Promise<SubagentToolResult> {
+      // Parallel mode
+      if (params.tasks && params.tasks.length > 0) {
+        const results: SubagentResult[] = await executeParallel({
+          tasks: params.tasks,
+          signal,
+          onUpdate: (progress: SubagentProgress[]) => {
+            onUpdate?.({
+              content: [],
+              details: {
+                mode: "parallel",
+                results: [],
+                progress,
+              },
+            });
+          },
+        });
+
+        return {
+          content: [{ type: "text", text: formatResultsSummary(results) }],
+          details: {
+            mode: "parallel",
+            results,
+            progress: results.map(r => r.progress).filter(Boolean) as SubagentProgress[] | undefined,
+          },
+        };
+      }
+
+      // Single mode
+      if (params.task) {
+        const result: SubagentResult = await executeSubagent({
+          agent: params.agent,
+          task: params.task,
+          model: params.model,
+          cwd: params.cwd,
+          signal,
+          onUpdate: (progress: SubagentProgress) => {
+            onUpdate?.({
+              content: [],
+              details: {
+                mode: "single",
+                results: [],
+                progress: [progress],
+              },
+            });
+          },
+        });
+
+        return {
+          content: [{ type: "text", text: result.finalOutput ?? result.error ?? "completed" }],
+          details: {
+            mode: "single",
+            results: [result],
+            progress: result.progress ? [result.progress] : undefined,
+          },
+          isError: result.exitCode !== 0,
+        };
+      }
+
+      return {
+        content: [{ type: "text", text: "Missing task parameter" }],
+        details: {
+          mode: "single",
+          results: [],
+        },
+        isError: true,
+      };
+    },
+
+    renderCall(args: unknown, theme: Theme, ctx: unknown): import("@earendil-works/pi-tui").Component {
+      const params = args as Record<string, unknown> | undefined;
+      const tasks = params?.tasks as Array<unknown> | undefined;
+      const agent = params?.agent as string | undefined;
+
+      const lastComponent = (ctx as { lastComponent?: import("@earendil-works/pi-tui").Component })?.lastComponent;
+      const text = (lastComponent instanceof Text ? lastComponent : new Text("", 0, 0)) as Text;
+      (ctx as Record<string, unknown>).lastComponent = text;
+
+      if (tasks && tasks.length > 0) {
+        const label = theme.fg("toolTitle", theme.bold("subagent")) + " " + tasks.length + " tasks";
+        text.setText(label);
+      } else if (agent) {
+        const label = theme.fg("toolTitle", theme.bold("subagent")) + " " + theme.fg("accent", agent);
+        text.setText(label);
+      } else {
+        text.setText(theme.fg("toolTitle", theme.bold("subagent")));
+      }
+
+      return text;
+    },
+
+    renderResult(result: unknown, options: unknown, theme: Theme, context: unknown): import("@earendil-works/pi-tui").Component {
+      const toolResult = result as unknown as SubagentToolResult;
+      const debugText = new Text("", 0, 0);
+      const expanded = ((context as Record<string, unknown>)?.expanded ??
+        (options as Record<string, unknown>)?.expanded ??
+        false) as boolean;
+
+      const renderTheme = theme as unknown as RenderTheme;
+      const text = new Text("", 0, 0);
+      const renderContext = {
+        expanded,
+        isError: toolResult.isError ?? false,
+        lastComponent: (context as { lastComponent?: Text })?.lastComponent,
+        state: (context as Record<string, unknown>)?.state ?? {},
+        invalidate: () => {},
+      };
+      (context as Record<string, unknown>).lastComponent = text;
+
+      try {
+        const rendered = renderSubagentResult(text, toolResult, { expanded }, renderTheme, renderContext as any);
+        return rendered;
+      } catch (e) {
+        debugText.setText("render error: " + (e instanceof Error ? e.message : String(e)));
+        return debugText;
+      }
+    },
+  });
+}
+
+// ── Helpers ─────────────────────────────────────────────────────────────────
+
+function formatProgressSummary(progress: SubagentProgress[]): string {
+  if (progress.length === 0) return "";
+  const lines = progress.map((p) => {
+    const tool = p.currentTool ? ` [${p.currentTool}]` : "";
+    const stats = [
+      p.toolCount > 0 ? p.toolCount + " tools" : "",
+      p.tokens > 0 ? Math.round(p.tokens / 1000) + "k tok" : "",
+    ].filter(Boolean).join(" · ");
+    return p.agent + tool + (stats ? " " + stats : "");
+  });
+  return lines.join("\n");
+}
+
+function formatResultsSummary(results: SubagentResult[]): string {
+  const lines = results.map((r) => {
+    const status = r.exitCode === 0 ? "✓" : "✗";
+    const summary = r.progressSummary
+      ? `${r.progressSummary.toolCount} tools · ${Math.round(r.progressSummary.tokens / 1000)}k tok · ${Math.round(r.progressSummary.durationMs / 1000)}s`
+      : "";
+    return `${status} ${r.agent}${summary ? " " + summary : ""}`;
+  });
+  return lines.join("\n");
+}
+
+// ── Default export ──────────────────────────────────────────────────────────
+
+export default function (pi: ExtensionAPI): void {
+  registerSubagent(pi);
+}