@oh-my-pi/pi-coding-agent 1.337.0

package/src/core/tools/task/render.ts

@@ -0,0 +1,232 @@
+/**
+ * TUI rendering for task tool.
+ *
+ * Provides renderCall and renderResult functions for displaying
+ * task execution in the terminal UI.
+ */
+
+import path from "node:path";
+import type { Component } from "@oh-my-pi/pi-tui";
+import { Text } from "@oh-my-pi/pi-tui";
+import type { Theme } from "../../../modes/interactive/theme/theme.js";
+import type { RenderResultOptions } from "../../custom-tools/types.js";
+import type { AgentProgress, SingleResult, TaskParams, TaskToolDetails } from "./types.js";
+
+/**
+ * Format token count for display (e.g., 1.5k, 25k).
+ */
+function formatTokens(tokens: number): string {
+	if (tokens >= 1000) {
+		return `${(tokens / 1000).toFixed(1)}k`;
+	}
+	return String(tokens);
+}
+
+/**
+ * Format duration for display.
+ */
+export function formatDuration(ms: number): string {
+	if (ms < 1000) return `${ms}ms`;
+	if (ms < 60000) return `${(ms / 1000).toFixed(1)}s`;
+	return `${(ms / 60000).toFixed(1)}m`;
+}
+
+/**
+ * Truncate text to max length with ellipsis.
+ */
+function truncate(text: string, maxLen: number): string {
+	if (text.length <= maxLen) return text;
+	return `${text.slice(0, maxLen - 3)}...`;
+}
+
+/**
+ * Get status icon for agent state.
+ */
+function getStatusIcon(status: AgentProgress["status"]): string {
+	switch (status) {
+		case "pending":
+			return "○";
+		case "running":
+			return "◐";
+		case "completed":
+			return "✓";
+		case "failed":
+			return "✗";
+	}
+}
+
+/**
+ * Render the tool call arguments.
+ */
+export function renderCall(args: TaskParams, theme: Theme): Component {
+	const label = theme.fg("toolTitle", theme.bold("task"));
+
+	if (args.tasks.length === 1) {
+		// Single task - show agent and task preview
+		const task = args.tasks[0];
+		const taskPreview = truncate(task.task, 60);
+		return new Text(`${label} ${theme.fg("accent", task.agent)}: ${theme.fg("muted", taskPreview)}`, 0, 0);
+	}
+
+	// Multiple tasks - show count and agent names
+	const agents = args.tasks.map((t) => t.agent).join(", ");
+	return new Text(`${label} ${theme.fg("muted", `${args.tasks.length} agents: ${truncate(agents, 50)}`)}`, 0, 0);
+}
+
+/**
+ * Render streaming progress for a single agent.
+ */
+function renderAgentProgress(progress: AgentProgress, isLast: boolean, expanded: boolean, theme: Theme): string[] {
+	const lines: string[] = [];
+	const prefix = isLast ? "└─" : "├─";
+	const continuePrefix = isLast ? "   " : "│  ";
+
+	const icon = getStatusIcon(progress.status);
+	const iconColor = progress.status === "completed" ? "success" : progress.status === "failed" ? "error" : "accent";
+
+	// Main status line
+	let statusLine = `${prefix} ${theme.fg(iconColor, icon)} ${theme.fg("accent", progress.agent)}`;
+
+	if (progress.status === "running") {
+		const taskPreview = truncate(progress.task, 40);
+		statusLine += `: ${theme.fg("muted", taskPreview)}`;
+		statusLine += ` · ${theme.fg("dim", `${progress.toolCount} tools`)}`;
+		if (progress.tokens > 0) {
+			statusLine += ` · ${theme.fg("dim", `${formatTokens(progress.tokens)} tokens`)}`;
+		}
+	} else if (progress.status === "completed") {
+		statusLine += `: ${theme.fg("success", "done")}`;
+		statusLine += ` · ${theme.fg("dim", `${progress.toolCount} tools`)}`;
+		statusLine += ` · ${theme.fg("dim", `${formatTokens(progress.tokens)} tokens`)}`;
+	} else if (progress.status === "failed") {
+		statusLine += `: ${theme.fg("error", "failed")}`;
+	}
+
+	lines.push(statusLine);
+
+	// Current tool (if running)
+	if (progress.status === "running" && progress.currentTool) {
+		let toolLine = `${continuePrefix}⎿ ${theme.fg("muted", progress.currentTool)}`;
+		if (progress.currentToolArgs) {
+			toolLine += `: ${theme.fg("dim", truncate(progress.currentToolArgs, 40))}`;
+		}
+		if (progress.currentToolStartMs) {
+			const elapsed = Date.now() - progress.currentToolStartMs;
+			if (elapsed > 5000) {
+				toolLine += ` · ${theme.fg("warning", formatDuration(elapsed))}`;
+			}
+		}
+		lines.push(toolLine);
+	}
+
+	// Expanded view: recent output and tools
+	if (expanded && progress.status === "running") {
+		// Recent output
+		for (const line of progress.recentOutput.slice(0, 3)) {
+			lines.push(`${continuePrefix}  ${theme.fg("dim", truncate(line, 60))}`);
+		}
+	}
+
+	return lines;
+}
+
+/**
+ * Render final result for a single agent.
+ */
+function renderAgentResult(result: SingleResult, isLast: boolean, expanded: boolean, theme: Theme): string[] {
+	const lines: string[] = [];
+	const prefix = isLast ? "└─" : "├─";
+	const continuePrefix = isLast ? "   " : "│  ";
+
+	const success = result.exitCode === 0;
+	const icon = success ? "✓" : "✗";
+	const iconColor = success ? "success" : "error";
+
+	// Main status line
+	let statusLine = `${prefix} ${theme.fg(iconColor, icon)} ${theme.fg("accent", result.agent)}`;
+	statusLine += `: ${theme.fg(iconColor, success ? "done" : "failed")}`;
+	statusLine += ` · ${theme.fg("dim", `${formatTokens(result.tokens)} tokens`)}`;
+	statusLine += ` · ${theme.fg("dim", formatDuration(result.durationMs))}`;
+
+	if (result.truncated) {
+		statusLine += ` ${theme.fg("warning", "[truncated]")}`;
+	}
+
+	lines.push(statusLine);
+
+	// Output preview
+	const outputLines = result.output.split("\n").filter((l) => l.trim());
+	const previewCount = expanded ? 8 : 3;
+
+	for (const line of outputLines.slice(0, previewCount)) {
+		lines.push(`${continuePrefix}${theme.fg("dim", truncate(line, 70))}`);
+	}
+
+	if (outputLines.length > previewCount) {
+		lines.push(`${continuePrefix}${theme.fg("dim", `... ${outputLines.length - previewCount} more lines`)}`);
+	}
+
+	// Error message
+	if (result.error && !success) {
+		lines.push(`${continuePrefix}${theme.fg("error", truncate(result.error, 70))}`);
+	}
+
+	return lines;
+}
+
+/**
+ * Render the tool result.
+ */
+export function renderResult(
+	result: { content: Array<{ type: string; text?: string }>; details?: TaskToolDetails },
+	options: RenderResultOptions,
+	theme: Theme,
+): Component {
+	const { expanded, isPartial } = options;
+	const details = result.details;
+
+	if (!details) {
+		// Fallback to simple text
+		const text = result.content.find((c) => c.type === "text")?.text || "";
+		return new Text(theme.fg("dim", truncate(text, 100)), 0, 0);
+	}
+
+	const lines: string[] = [];
+
+	if (isPartial && details.progress) {
+		// Streaming progress view
+		details.progress.forEach((progress, i) => {
+			const isLast = i === details.progress!.length - 1;
+			lines.push(...renderAgentProgress(progress, isLast, expanded, theme));
+		});
+	} else if (details.results.length > 0) {
+		// Final results view
+		details.results.forEach((res, i) => {
+			const isLast = i === details.results.length - 1;
+			lines.push(...renderAgentResult(res, isLast, expanded, theme));
+		});
+
+		// Summary line
+		const successCount = details.results.filter((r) => r.exitCode === 0).length;
+		const failCount = details.results.length - successCount;
+		let summary = `\n${theme.fg("dim", "Total:")} `;
+		summary += theme.fg("success", `${successCount} succeeded`);
+		if (failCount > 0) {
+			summary += `, ${theme.fg("error", `${failCount} failed`)}`;
+		}
+		summary += ` · ${theme.fg("dim", formatDuration(details.totalDurationMs))}`;
+		lines.push(summary);
+
+		// Artifacts location
+		if (details.outputPaths && details.outputPaths.length > 0) {
+			const artifactsDir = path.dirname(details.outputPaths[0]);
+			lines.push(`${theme.fg("dim", "Artifacts:")} ${theme.fg("muted", artifactsDir)}`);
+		}
+	}
+
+	if (lines.length === 0) {
+		return new Text(theme.fg("dim", "No results"), 0, 0);
+	}
+
+	return new Text(lines.join("\n"), 0, 0);
+}

package/src/core/tools/task/types.ts

@@ -0,0 +1,99 @@
+import { type Static, Type } from "@sinclair/typebox";
+
+/** Source of an agent definition */
+export type AgentSource = "bundled" | "user" | "project";
+
+/** Single task item for parallel execution */
+export const taskItemSchema = Type.Object({
+	agent: Type.String({ description: "Agent name" }),
+	task: Type.String({ description: "Task description for the agent" }),
+	model: Type.Optional(Type.String({ description: "Model override for this task" })),
+});
+
+export type TaskItem = Static<typeof taskItemSchema>;
+
+/** Maximum tasks per call */
+export const MAX_PARALLEL_TASKS = 32;
+
+/** Maximum concurrent workers */
+export const MAX_CONCURRENCY = 16;
+
+/** Maximum output bytes per agent */
+export const MAX_OUTPUT_BYTES = 500_000;
+
+/** Maximum output lines per agent */
+export const MAX_OUTPUT_LINES = 5000;
+
+/** Maximum agents to show in description */
+export const MAX_AGENTS_IN_DESCRIPTION = 10;
+
+/** Environment variable to inhibit subagent spawning */
+export const PI_NO_SUBAGENTS_ENV = "PI_NO_SUBAGENTS";
+
+/** Task tool parameters */
+export const taskSchema = Type.Object({
+	context: Type.Optional(Type.String({ description: "Shared context prepended to all task prompts" })),
+	tasks: Type.Array(taskItemSchema, {
+		description: "Tasks to run in parallel",
+		maxItems: MAX_PARALLEL_TASKS,
+	}),
+});
+
+export type TaskParams = Static<typeof taskSchema>;
+
+/** Agent definition (bundled or discovered) */
+export interface AgentDefinition {
+	name: string;
+	description: string;
+	systemPrompt: string;
+	tools?: string[];
+	model?: string;
+	recursive?: boolean;
+	source: AgentSource;
+	filePath?: string;
+}
+
+/** Progress tracking for a single agent */
+export interface AgentProgress {
+	index: number;
+	agent: string;
+	agentSource: AgentSource;
+	status: "pending" | "running" | "completed" | "failed";
+	task: string;
+	currentTool?: string;
+	currentToolArgs?: string;
+	currentToolStartMs?: number;
+	recentTools: Array<{ tool: string; args: string; endMs: number }>;
+	recentOutput: string[];
+	toolCount: number;
+	tokens: number;
+	durationMs: number;
+	modelOverride?: string;
+}
+
+/** Result from a single agent execution */
+export interface SingleResult {
+	index: number;
+	agent: string;
+	agentSource: AgentSource;
+	task: string;
+	exitCode: number;
+	output: string;
+	stderr: string;
+	truncated: boolean;
+	durationMs: number;
+	tokens: number;
+	modelOverride?: string;
+	error?: string;
+	jsonlEvents?: string[];
+	artifactPaths?: { inputPath: string; outputPath: string; jsonlPath?: string };
+}
+
+/** Tool details for TUI rendering */
+export interface TaskToolDetails {
+	projectAgentsDir: string | null;
+	results: SingleResult[];
+	totalDurationMs: number;
+	outputPaths?: string[];
+	progress?: AgentProgress[];
+}

package/src/core/tools/truncate.ts

@@ -0,0 +1,265 @@
+/**
+ * Shared truncation utilities for tool outputs.
+ *
+ * Truncation is based on two independent limits - whichever is hit first wins:
+ * - Line limit (default: 2000 lines)
+ * - Byte limit (default: 50KB)
+ *
+ * Never returns partial lines (except bash tail truncation edge case).
+ */
+
+export const DEFAULT_MAX_LINES = 2000;
+export const DEFAULT_MAX_BYTES = 50 * 1024; // 50KB
+export const GREP_MAX_LINE_LENGTH = 500; // Max chars per grep match line
+
+export interface TruncationResult {
+	/** The truncated content */
+	content: string;
+	/** Whether truncation occurred */
+	truncated: boolean;
+	/** Which limit was hit: "lines", "bytes", or null if not truncated */
+	truncatedBy: "lines" | "bytes" | null;
+	/** Total number of lines in the original content */
+	totalLines: number;
+	/** Total number of bytes in the original content */
+	totalBytes: number;
+	/** Number of complete lines in the truncated output */
+	outputLines: number;
+	/** Number of bytes in the truncated output */
+	outputBytes: number;
+	/** Whether the last line was partially truncated (only for tail truncation edge case) */
+	lastLinePartial: boolean;
+	/** Whether the first line exceeded the byte limit (for head truncation) */
+	firstLineExceedsLimit: boolean;
+	/** The max lines limit that was applied */
+	maxLines: number;
+	/** The max bytes limit that was applied */
+	maxBytes: number;
+}
+
+export interface TruncationOptions {
+	/** Maximum number of lines (default: 2000) */
+	maxLines?: number;
+	/** Maximum number of bytes (default: 50KB) */
+	maxBytes?: number;
+}
+
+/**
+ * Format bytes as human-readable size.
+ */
+export function formatSize(bytes: number): string {
+	if (bytes < 1024) {
+		return `${bytes}B`;
+	} else if (bytes < 1024 * 1024) {
+		return `${(bytes / 1024).toFixed(1)}KB`;
+	} else {
+		return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
+	}
+}
+
+/**
+ * Truncate content from the head (keep first N lines/bytes).
+ * Suitable for file reads where you want to see the beginning.
+ *
+ * Never returns partial lines. If first line exceeds byte limit,
+ * returns empty content with firstLineExceedsLimit=true.
+ */
+export function truncateHead(content: string, options: TruncationOptions = {}): TruncationResult {
+	const maxLines = options.maxLines ?? DEFAULT_MAX_LINES;
+	const maxBytes = options.maxBytes ?? DEFAULT_MAX_BYTES;
+
+	const totalBytes = Buffer.byteLength(content, "utf-8");
+	const lines = content.split("\n");
+	const totalLines = lines.length;
+
+	// Check if no truncation needed
+	if (totalLines <= maxLines && totalBytes <= maxBytes) {
+		return {
+			content,
+			truncated: false,
+			truncatedBy: null,
+			totalLines,
+			totalBytes,
+			outputLines: totalLines,
+			outputBytes: totalBytes,
+			lastLinePartial: false,
+			firstLineExceedsLimit: false,
+			maxLines,
+			maxBytes,
+		};
+	}
+
+	// Check if first line alone exceeds byte limit
+	const firstLineBytes = Buffer.byteLength(lines[0], "utf-8");
+	if (firstLineBytes > maxBytes) {
+		return {
+			content: "",
+			truncated: true,
+			truncatedBy: "bytes",
+			totalLines,
+			totalBytes,
+			outputLines: 0,
+			outputBytes: 0,
+			lastLinePartial: false,
+			firstLineExceedsLimit: true,
+			maxLines,
+			maxBytes,
+		};
+	}
+
+	// Collect complete lines that fit
+	const outputLinesArr: string[] = [];
+	let outputBytesCount = 0;
+	let truncatedBy: "lines" | "bytes" = "lines";
+
+	for (let i = 0; i < lines.length && i < maxLines; i++) {
+		const line = lines[i];
+		const lineBytes = Buffer.byteLength(line, "utf-8") + (i > 0 ? 1 : 0); // +1 for newline
+
+		if (outputBytesCount + lineBytes > maxBytes) {
+			truncatedBy = "bytes";
+			break;
+		}
+
+		outputLinesArr.push(line);
+		outputBytesCount += lineBytes;
+	}
+
+	// If we exited due to line limit
+	if (outputLinesArr.length >= maxLines && outputBytesCount <= maxBytes) {
+		truncatedBy = "lines";
+	}
+
+	const outputContent = outputLinesArr.join("\n");
+	const finalOutputBytes = Buffer.byteLength(outputContent, "utf-8");
+
+	return {
+		content: outputContent,
+		truncated: true,
+		truncatedBy,
+		totalLines,
+		totalBytes,
+		outputLines: outputLinesArr.length,
+		outputBytes: finalOutputBytes,
+		lastLinePartial: false,
+		firstLineExceedsLimit: false,
+		maxLines,
+		maxBytes,
+	};
+}
+
+/**
+ * Truncate content from the tail (keep last N lines/bytes).
+ * Suitable for bash output where you want to see the end (errors, final results).
+ *
+ * May return partial first line if the last line of original content exceeds byte limit.
+ */
+export function truncateTail(content: string, options: TruncationOptions = {}): TruncationResult {
+	const maxLines = options.maxLines ?? DEFAULT_MAX_LINES;
+	const maxBytes = options.maxBytes ?? DEFAULT_MAX_BYTES;
+
+	const totalBytes = Buffer.byteLength(content, "utf-8");
+	const lines = content.split("\n");
+	const totalLines = lines.length;
+
+	// Check if no truncation needed
+	if (totalLines <= maxLines && totalBytes <= maxBytes) {
+		return {
+			content,
+			truncated: false,
+			truncatedBy: null,
+			totalLines,
+			totalBytes,
+			outputLines: totalLines,
+			outputBytes: totalBytes,
+			lastLinePartial: false,
+			firstLineExceedsLimit: false,
+			maxLines,
+			maxBytes,
+		};
+	}
+
+	// Work backwards from the end
+	const outputLinesArr: string[] = [];
+	let outputBytesCount = 0;
+	let truncatedBy: "lines" | "bytes" = "lines";
+	let lastLinePartial = false;
+
+	for (let i = lines.length - 1; i >= 0 && outputLinesArr.length < maxLines; i--) {
+		const line = lines[i];
+		const lineBytes = Buffer.byteLength(line, "utf-8") + (outputLinesArr.length > 0 ? 1 : 0); // +1 for newline
+
+		if (outputBytesCount + lineBytes > maxBytes) {
+			truncatedBy = "bytes";
+			// Edge case: if we haven't added ANY lines yet and this line exceeds maxBytes,
+			// take the end of the line (partial)
+			if (outputLinesArr.length === 0) {
+				const truncatedLine = truncateStringToBytesFromEnd(line, maxBytes);
+				outputLinesArr.unshift(truncatedLine);
+				outputBytesCount = Buffer.byteLength(truncatedLine, "utf-8");
+				lastLinePartial = true;
+			}
+			break;
+		}
+
+		outputLinesArr.unshift(line);
+		outputBytesCount += lineBytes;
+	}
+
+	// If we exited due to line limit
+	if (outputLinesArr.length >= maxLines && outputBytesCount <= maxBytes) {
+		truncatedBy = "lines";
+	}
+
+	const outputContent = outputLinesArr.join("\n");
+	const finalOutputBytes = Buffer.byteLength(outputContent, "utf-8");
+
+	return {
+		content: outputContent,
+		truncated: true,
+		truncatedBy,
+		totalLines,
+		totalBytes,
+		outputLines: outputLinesArr.length,
+		outputBytes: finalOutputBytes,
+		lastLinePartial,
+		firstLineExceedsLimit: false,
+		maxLines,
+		maxBytes,
+	};
+}
+
+/**
+ * Truncate a string to fit within a byte limit (from the end).
+ * Handles multi-byte UTF-8 characters correctly.
+ */
+function truncateStringToBytesFromEnd(str: string, maxBytes: number): string {
+	const buf = Buffer.from(str, "utf-8");
+	if (buf.length <= maxBytes) {
+		return str;
+	}
+
+	// Start from the end, skip maxBytes back
+	let start = buf.length - maxBytes;
+
+	// Find a valid UTF-8 boundary (start of a character)
+	while (start < buf.length && (buf[start] & 0xc0) === 0x80) {
+		start++;
+	}
+
+	return buf.slice(start).toString("utf-8");
+}
+
+/**
+ * Truncate a single line to max characters, adding [truncated] suffix.
+ * Used for grep match lines.
+ */
+export function truncateLine(
+	line: string,
+	maxChars: number = GREP_MAX_LINE_LENGTH,
+): { text: string; wasTruncated: boolean } {
+	if (line.length <= maxChars) {
+		return { text: line, wasTruncated: false };
+	}
+	return { text: `${line.slice(0, maxChars)}... [truncated]`, wasTruncated: true };
+}