pi-subagents 0.13.4 → 0.14.1

package/utils.ts

@@ -6,13 +6,12 @@ import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
 import type { Message } from "@mariozechner/pi-ai";
-import type { AsyncStatus, DisplayItem, ErrorInfo, SingleResult } from "./types.ts";
+import type { AgentProgress, AsyncStatus, Details, DisplayItem, ErrorInfo, SingleResult } from "./types.ts";
 
 // ============================================================================
 // File System Utilities
 // ============================================================================
 
-// Cache for status file reads - avoid re-reading unchanged files
 const statusCache = new Map<string, { mtime: number; status: AsyncStatus }>();
 
 function getErrorMessage(error: unknown): string {
@@ -74,7 +73,6 @@ export function readStatus(asyncDir: string): AsyncStatus | null {
 	return status;
 }
 
-// Cache for output tail reads - avoid re-reading unchanged files
 const outputTailCache = new Map<string, { mtime: number; size: number; lines: string[] }>();
 
 /**
@@ -87,7 +85,6 @@ export function getOutputTail(outputFile: string | undefined, maxLines: number =
 		const stat = fs.statSync(outputFile);
 		if (stat.size === 0) return [];
 
-		// Check cache using both mtime and size (size changes more frequently during writes)
 		const cached = outputTailCache.get(outputFile);
 		if (cached && cached.mtime === stat.mtimeMs && cached.size === stat.size) {
 			return cached.lines;
@@ -102,9 +99,7 @@ export function getOutputTail(outputFile: string | undefined, maxLines: number =
 		const allLines = content.split("\n").filter((l) => l.trim());
 		const lines = allLines.slice(-maxLines).map((l) => l.slice(0, 120) + (l.length > 120 ? "..." : ""));
 
-		// Cache the result
 		outputTailCache.set(outputFile, { mtime: stat.mtimeMs, size: stat.size, lines });
-		// Limit cache size
 		if (outputTailCache.size > 20) {
 			const firstKey = outputTailCache.keys().next().value;
 			if (firstKey) outputTailCache.delete(firstKey);
@@ -112,12 +107,15 @@ export function getOutputTail(outputFile: string | undefined, maxLines: number =
 
 		return lines;
 	} catch {
+		// Output tails are UI-only hints; unreadable or missing files should render as no tail.
 		return [];
 	} finally {
 		if (fd !== null) {
 			try {
 				fs.closeSync(fd);
-			} catch {}
+			} catch {
+				// Closing the best-effort tail file handle should not surface over the main status view.
+			}
 		}
 	}
 }
@@ -125,16 +123,16 @@ export function getOutputTail(outputFile: string | undefined, maxLines: number =
 /**
  * Get human-readable last activity time for a file
  */
-export function getLastActivity(outputFile: string | undefined): string {
+	export function getLastActivity(outputFile: string | undefined): string {
 	if (!outputFile) return "";
 	try {
-		// Single stat call - throws if file doesn't exist
 		const stat = fs.statSync(outputFile);
 		const ago = Date.now() - stat.mtimeMs;
 		if (ago < 1000) return "active now";
 		if (ago < 60000) return `active ${Math.floor(ago / 1000)}s ago`;
 		return `active ${Math.floor(ago / 60000)}m ago`;
 	} catch {
+		// Last-activity text is best effort; missing files should simply omit the hint.
 		return "";
 	}
 }
@@ -201,13 +199,14 @@ export function getFinalOutput(messages: Message[]): string {
 }
 
 export function getSingleResultOutput(result: Pick<SingleResult, "finalOutput" | "messages">): string {
-	return result.finalOutput ?? getFinalOutput(result.messages);
+	return result.finalOutput ?? getFinalOutput(result.messages ?? []);
 }
 
 /**
  * Extract display items (text and tool calls) from messages
  */
-export function getDisplayItems(messages: Message[]): DisplayItem[] {
+export function getDisplayItems(messages: Message[] | undefined): DisplayItem[] {
+	if (!messages || messages.length === 0) return [];
 	const items: DisplayItem[] = [];
 	for (const msg of messages) {
 		if (msg.role === "assistant") {
@@ -220,19 +219,53 @@ export function getDisplayItems(messages: Message[]): DisplayItem[] {
 	return items;
 }
 
+function compactCompletedProgress(progress: AgentProgress): AgentProgress {
+	if (progress.status === "running") return progress;
+	return {
+		index: progress.index,
+		agent: progress.agent,
+		status: progress.status,
+		task: progress.task,
+		skills: progress.skills,
+		toolCount: progress.toolCount,
+		tokens: progress.tokens,
+		durationMs: progress.durationMs,
+		error: progress.error,
+		failedTool: progress.failedTool,
+		recentTools: [],
+		recentOutput: [],
+	};
+}
+
+export function compactForegroundResult(result: SingleResult): SingleResult {
+	if (result.progress?.status === "running") return result;
+	return {
+		...result,
+		messages: undefined,
+		progress: undefined,
+	};
+}
+
+export function compactForegroundDetails(details: Details): Details {
+	return {
+		...details,
+		results: details.results.map(compactForegroundResult),
+		progress: details.progress
+			? details.progress.map(compactCompletedProgress)
+			: undefined,
+	};
+}
+
 /**
  * Detect errors in subagent execution from messages (only errors with no subsequent success)
  */
 export function detectSubagentError(messages: Message[]): ErrorInfo {
-	// Step 1: Find the last assistant message with text content.
-	// If the agent produced a text response after encountering errors,
-	// it had a chance to recover — only errors AFTER this point matter.
 	let lastAssistantTextIndex = -1;
 	for (let i = messages.length - 1; i >= 0; i--) {
 		const msg = messages[i];
 		if (msg.role === "assistant") {
 			const hasText = Array.isArray(msg.content) && msg.content.some(
-				(c) => c.type === "text" && "text" in c && (c.text as string).trim().length > 0,
+				(c) => c.type === "text" && "text" in c && typeof c.text === "string" && c.text.trim().length > 0,
 			);
 			if (hasText) {
 				lastAssistantTextIndex = i;
@@ -241,28 +274,26 @@ export function detectSubagentError(messages: Message[]): ErrorInfo {
 		}
 	}
 
-	// Step 2: Only scan tool results AFTER the last assistant text message.
-	// Errors before the agent's final response are implicitly recovered.
 	const scanStart = lastAssistantTextIndex >= 0 ? lastAssistantTextIndex + 1 : 0;
 
-	// Step 3: Check tool results in the post-response window
 	for (let i = messages.length - 1; i >= scanStart; i--) {
 		const msg = messages[i];
 		if (msg.role !== "toolResult") continue;
+		const toolName = "toolName" in msg && typeof msg.toolName === "string" ? msg.toolName : undefined;
+		const isError = "isError" in msg && msg.isError === true;
 
-		if ((msg as any).isError) {
+		if (isError) {
 			const text = msg.content.find((c) => c.type === "text");
 			const details = text && "text" in text ? text.text : undefined;
 			const exitMatch = details?.match(/exit(?:ed)?\s*(?:with\s*)?(?:code|status)?\s*[:\s]?\s*(\d+)/i);
 			return {
 				hasError: true,
 				exitCode: exitMatch ? parseInt(exitMatch[1], 10) : 1,
-				errorType: (msg as any).toolName || "tool",
+				errorType: toolName || "tool",
 				details: details?.slice(0, 200),
 			};
 		}
 
-		const toolName = (msg as any).toolName;
 		if (toolName !== "bash") continue;
 
 		const text = msg.content.find((c) => c.type === "text");