@oh-my-pi/pi-coding-agent 1.340.0 → 2.0.1337

package/src/core/tools/output.ts

@@ -0,0 +1,175 @@
+/**
+ * Output tool for reading agent/task outputs by ID.
+ *
+ * Resolves IDs like "reviewer_0" to artifact paths in the current session.
+ */
+
+import * as fs from "node:fs";
+import * as path from "node:path";
+import type { AgentTool } from "@oh-my-pi/pi-agent-core";
+import type { TextContent } from "@oh-my-pi/pi-ai";
+import { Type } from "@sinclair/typebox";
+import type { SessionContext } from "./index";
+import { getArtifactsDir } from "./task/artifacts";
+
+const outputSchema = Type.Object({
+	ids: Type.Array(Type.String(), {
+		description: "Agent output IDs to read (e.g., ['reviewer_0', 'explore_1'])",
+		minItems: 1,
+	}),
+	format: Type.Optional(
+		Type.Union([Type.Literal("raw"), Type.Literal("json"), Type.Literal("stripped")], {
+			description: "Output format: raw (default), json (structured), stripped (no ANSI)",
+		}),
+	),
+});
+
+/** Metadata for a single output file */
+interface OutputEntry {
+	id: string;
+	path: string;
+	lineCount: number;
+	charCount: number;
+}
+
+export interface OutputToolDetails {
+	outputs: OutputEntry[];
+	notFound?: string[];
+	availableIds?: string[];
+}
+
+/** Strip ANSI escape codes from text */
+function stripAnsi(text: string): string {
+	return text.replace(/\x1b\[[0-9;]*m/g, "");
+}
+
+/** List available output IDs in artifacts directory */
+function listAvailableOutputs(artifactsDir: string): string[] {
+	try {
+		const files = fs.readdirSync(artifactsDir);
+		return files.filter((f) => f.endsWith(".out.md")).map((f) => f.replace(".out.md", ""));
+	} catch {
+		return [];
+	}
+}
+
+/** Format byte count for display */
+function formatBytes(bytes: number): string {
+	if (bytes < 1024) return `${bytes}B`;
+	if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)}K`;
+	return `${(bytes / (1024 * 1024)).toFixed(1)}M`;
+}
+
+export function createOutputTool(
+	_cwd: string,
+	sessionContext?: SessionContext,
+): AgentTool<typeof outputSchema, OutputToolDetails> {
+	return {
+		name: "output",
+		label: "Output",
+		description: `Read full agent/task output by ID.
+
+Use when the Task tool's truncated preview isn't sufficient for your needs.
+The Task tool already returns summaries with line/char counts in its result.
+
+Parameters:
+- ids: Array of output IDs (e.g., ["reviewer_0", "explore_1"])
+- format: "raw" (default), "json" (structured object), or "stripped" (no ANSI codes)
+
+Returns the full output content. For unknown IDs, returns an error with available IDs.
+
+Example: { "ids": ["reviewer_0"] }`,
+		parameters: outputSchema,
+		execute: async (
+			_toolCallId: string,
+			params: { ids: string[]; format?: "raw" | "json" | "stripped" },
+		): Promise<{ content: TextContent[]; details: OutputToolDetails }> => {
+			const sessionFile = sessionContext?.getSessionFile();
+
+			if (!sessionFile) {
+				return {
+					content: [{ type: "text", text: "No session - output artifacts unavailable" }],
+					details: { outputs: [], notFound: params.ids },
+				};
+			}
+
+			const artifactsDir = getArtifactsDir(sessionFile);
+			if (!artifactsDir || !fs.existsSync(artifactsDir)) {
+				return {
+					content: [{ type: "text", text: "No artifacts directory found" }],
+					details: { outputs: [], notFound: params.ids },
+				};
+			}
+
+			const outputs: OutputEntry[] = [];
+			const notFound: string[] = [];
+			const format = params.format ?? "raw";
+
+			for (const id of params.ids) {
+				const outputPath = path.join(artifactsDir, `${id}.out.md`);
+
+				if (!fs.existsSync(outputPath)) {
+					notFound.push(id);
+					continue;
+				}
+
+				const content = fs.readFileSync(outputPath, "utf-8");
+				outputs.push({
+					id,
+					path: outputPath,
+					lineCount: content.split("\n").length,
+					charCount: content.length,
+				});
+			}
+
+			// Error case: some IDs not found
+			if (notFound.length > 0) {
+				const available = listAvailableOutputs(artifactsDir);
+				const errorMsg =
+					available.length > 0
+						? `Not found: ${notFound.join(", ")}\nAvailable: ${available.join(", ")}`
+						: `Not found: ${notFound.join(", ")}\nNo outputs available in current session`;
+
+				return {
+					content: [{ type: "text", text: errorMsg }],
+					details: { outputs, notFound, availableIds: available },
+				};
+			}
+
+			// Success: build response based on format
+			let contentText: string;
+
+			if (format === "json") {
+				const jsonData = outputs.map((o) => ({
+					id: o.id,
+					lineCount: o.lineCount,
+					charCount: o.charCount,
+					content: fs.readFileSync(o.path, "utf-8"),
+				}));
+				contentText = JSON.stringify(jsonData, null, 2);
+			} else {
+				// raw or stripped
+				const parts = outputs.map((o) => {
+					let content = fs.readFileSync(o.path, "utf-8");
+					if (format === "stripped") {
+						content = stripAnsi(content);
+					}
+					// Add header for multiple outputs
+					if (outputs.length > 1) {
+						return `=== ${o.id} (${o.lineCount} lines, ${formatBytes(o.charCount)}) ===\n${content}`;
+					}
+					return content;
+				});
+				contentText = parts.join("\n\n");
+			}
+
+			return {
+				content: [{ type: "text", text: contentText }],
+				details: { outputs },
+			};
+		},
+	};
+}
+
+/** Default output tool using process.cwd() - for backwards compatibility */
+export const outputTool = createOutputTool(process.cwd());

package/src/core/tools/read.ts

@@ -1,13 +1,13 @@
+import { spawnSync } from "node:child_process";
+import { constants } from "node:fs";
+import { access, readFile } from "node:fs/promises";
+import { extname } from "node:path";
 import type { AgentTool } from "@oh-my-pi/pi-agent-core";
 import type { ImageContent, TextContent } from "@oh-my-pi/pi-ai";
 import { Type } from "@sinclair/typebox";
-import { spawnSync } from "child_process";
-import { constants } from "fs";
-import { access, readFile } from "fs/promises";
-import { extname } from "path";
-import { detectSupportedImageMimeTypeFromFile } from "../../utils/mime.js";
-import { resolveReadPath } from "./path-utils.js";
-import { DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES, formatSize, type TruncationResult, truncateHead } from "./truncate.js";
+import { detectSupportedImageMimeTypeFromFile } from "../../utils/mime";
+import { resolveReadPath } from "./path-utils";
+import { DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES, formatSize, type TruncationResult, truncateHead } from "./truncate";
 
 // Document types convertible via markitdown
 const CONVERTIBLE_EXTENSIONS = new Set([".pdf", ".doc", ".docx", ".ppt", ".pptx", ".xls", ".xlsx", ".rtf", ".epub"]);

package/src/core/tools/renderers.ts

@@ -6,19 +6,20 @@
 
 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 { AskToolDetails } from "./ask.js";
-import type { FindToolDetails } from "./find.js";
-import type { GrepToolDetails } from "./grep.js";
-import type { LsToolDetails } from "./ls.js";
-import { renderCall as renderLspCall, renderResult as renderLspResult } from "./lsp/render.js";
-import type { LspToolDetails } from "./lsp/types.js";
-import type { NotebookToolDetails } from "./notebook.js";
-import { renderCall as renderTaskCall, renderResult as renderTaskResult } from "./task/render.js";
-import type { TaskToolDetails } from "./task/types.js";
-import { renderWebFetchCall, renderWebFetchResult, type WebFetchToolDetails } from "./web-fetch.js";
-import { renderWebSearchCall, renderWebSearchResult, type WebSearchRenderDetails } from "./web-search/render.js";
+import type { Theme } from "../../modes/interactive/theme/theme";
+import type { RenderResultOptions } from "../custom-tools/types";
+import type { AskToolDetails } from "./ask";
+import type { FindToolDetails } from "./find";
+import type { GrepToolDetails } from "./grep";
+import type { LsToolDetails } from "./ls";
+import { renderCall as renderLspCall, renderResult as renderLspResult } from "./lsp/render";
+import type { LspToolDetails } from "./lsp/types";
+import type { NotebookToolDetails } from "./notebook";
+import type { OutputToolDetails } from "./output";
+import { renderCall as renderTaskCall, renderResult as renderTaskResult } from "./task/render";
+import type { TaskToolDetails } from "./task/types";
+import { renderWebFetchCall, renderWebFetchResult, type WebFetchToolDetails } from "./web-fetch";
+import { renderWebSearchCall, renderWebSearchResult, type WebSearchRenderDetails } from "./web-search/render";
 
 // Tree drawing characters
 const TREE_MID = "├─";
@@ -416,6 +417,83 @@ const lspRenderer: ToolRenderer<LspArgs, LspToolDetails> = {
 	renderResult: renderLspResult,
 };
 
+// ============================================================================
+// Output Renderer
+// ============================================================================
+
+interface OutputArgs {
+	ids: string[];
+	format?: "raw" | "json" | "stripped";
+}
+
+/** Format byte count for display */
+function formatBytes(bytes: number): string {
+	if (bytes < 1024) return `${bytes}B`;
+	if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)}K`;
+	return `${(bytes / (1024 * 1024)).toFixed(1)}M`;
+}
+
+const outputRenderer: ToolRenderer<OutputArgs, OutputToolDetails> = {
+	renderCall(args, theme) {
+		const ids = args.ids?.join(", ") ?? "?";
+		const label = theme.fg("toolTitle", theme.bold("output"));
+		const format = args.format && args.format !== "raw" ? theme.fg("muted", ` (${args.format})`) : "";
+		return new Text(`${label} ${theme.fg("dim", ids)}${format}`, 0, 0);
+	},
+
+	renderResult(result, { expanded }, theme) {
+		const details = result.details;
+
+		// Error case: some IDs not found
+		if (details?.notFound?.length) {
+			let text = `${theme.fg("error", ICON_ERROR)} Not found: ${details.notFound.join(", ")}`;
+			if (details.availableIds?.length) {
+				text += `\n${theme.fg("dim", "Available:")} ${details.availableIds.join(", ")}`;
+			} else {
+				text += `\n${theme.fg("dim", "No outputs available in current session")}`;
+			}
+			return new Text(text, 0, 0);
+		}
+
+		const outputs = details?.outputs ?? [];
+
+		// No session case
+		if (outputs.length === 0) {
+			const textContent = result.content?.find((c: any) => c.type === "text")?.text;
+			return new Text(
+				`${theme.fg("warning", ICON_WARNING)} ${theme.fg("muted", textContent || "No outputs")}`,
+				0,
+				0,
+			);
+		}
+
+		// Success: single output
+		if (outputs.length === 1) {
+			const o = outputs[0];
+			const summary = `read ${o.id}.out.md (${o.lineCount} lines, ${formatBytes(o.charCount)})`;
+			return new Text(`${theme.fg("success", ICON_SUCCESS)} ${theme.fg("dim", summary)}`, 0, 0);
+		}
+
+		// Success: multiple outputs (tree display)
+		const expandHint = expanded ? "" : theme.fg("dim", " (Ctrl+O to expand)");
+		let text = `${theme.fg("success", ICON_SUCCESS)} ${theme.fg("dim", `read ${outputs.length} outputs`)}${expandHint}`;
+
+		const maxOutputs = expanded ? outputs.length : Math.min(outputs.length, 5);
+		for (let i = 0; i < maxOutputs; i++) {
+			const o = outputs[i];
+			const isLast = i === maxOutputs - 1 && (expanded || outputs.length <= 5);
+			const branch = isLast ? TREE_END : TREE_MID;
+			text += `\n ${theme.fg("dim", branch)} ${theme.fg("accent", o.id)} ${theme.fg("dim", `(${o.lineCount} lines)`)}`;
+		}
+
+		if (!expanded && outputs.length > 5) {
+			text += `\n ${theme.fg("dim", TREE_END)} ${theme.fg("muted", `… ${outputs.length - 5} more outputs`)}`;
+		}
+
+		return new Text(text, 0, 0);
+	},
+};
+
 // ============================================================================
 // Task Renderer
 // ============================================================================
@@ -534,6 +612,7 @@ export const toolRenderers: Record<
 	notebook: notebookRenderer,
 	ls: lsRenderer,
 	lsp: lspRenderer,
+	output: outputRenderer,
 	task: taskRenderer,
 	web_fetch: webFetchRenderer,
 	web_search: webSearchRenderer,

package/src/core/tools/review.ts

@@ -0,0 +1,268 @@
+/**
+ * Review tools - report_finding and submit_review
+ *
+ * Used by the reviewer agent to report findings in a structured way.
+ * Both tools are hidden by default - only enabled when explicitly listed in agent's tools.
+ */
+
+import type { AgentTool } from "@oh-my-pi/pi-agent-core";
+import type { Component } from "@oh-my-pi/pi-tui";
+import { Container, Spacer, Text } from "@oh-my-pi/pi-tui";
+import { Type } from "@sinclair/typebox";
+import type { Theme } from "../../modes/interactive/theme/theme";
+
+const PRIORITY_LABELS: Record<number, string> = {
+	0: "P0",
+	1: "P1",
+	2: "P2",
+	3: "P3",
+};
+
+const _PRIORITY_DESCRIPTIONS: Record<number, string> = {
+	0: "Drop everything to fix. Blocking release, operations, or major usage.",
+	1: "Urgent. Should be addressed in the next cycle.",
+	2: "Normal. To be fixed eventually.",
+	3: "Low. Nice to have.",
+};
+
+// report_finding schema
+const ReportFindingParams = Type.Object({
+	title: Type.String({
+		description: "≤80 chars, imperative, prefixed with [P0-P3]. E.g., '[P1] Un-padding slices along wrong dimension'",
+	}),
+	body: Type.String({
+		description: "Markdown explaining why this is a problem. One paragraph max.",
+	}),
+	priority: Type.Union([Type.Literal(0), Type.Literal(1), Type.Literal(2), Type.Literal(3)], {
+		description: "0=P0 (critical), 1=P1 (urgent), 2=P2 (normal), 3=P3 (low)",
+	}),
+	confidence: Type.Number({
+		minimum: 0,
+		maximum: 1,
+		description: "Confidence score 0.0-1.0",
+	}),
+	file_path: Type.String({ description: "Absolute path to the file" }),
+	line_start: Type.Number({ description: "Start line of the issue" }),
+	line_end: Type.Number({ description: "End line of the issue" }),
+});
+
+interface ReportFindingDetails {
+	title: string;
+	body: string;
+	priority: number;
+	confidence: number;
+	file_path: string;
+	line_start: number;
+	line_end: number;
+}
+
+export const reportFindingTool: AgentTool<typeof ReportFindingParams, ReportFindingDetails, Theme> = {
+	name: "report_finding",
+	label: "Report Finding",
+	description: "Report a code review finding. Use this for each issue found. Call submit_review when done.",
+	parameters: ReportFindingParams,
+	hidden: true,
+
+	async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
+		const { title, body, priority, confidence, file_path, line_start, line_end } = params;
+		const location = `${file_path}:${line_start}${line_end !== line_start ? `-${line_end}` : ""}`;
+
+		return {
+			content: [
+				{
+					type: "text",
+					text: `Finding recorded: ${PRIORITY_LABELS[priority]} ${title}\nLocation: ${location}\nConfidence: ${(confidence * 100).toFixed(0)}%`,
+				},
+			],
+			details: { title, body, priority, confidence, file_path, line_start, line_end },
+		};
+	},
+
+	renderCall(args, theme): Component {
+		const priority = PRIORITY_LABELS[args.priority as number] ?? "P?";
+		const color = args.priority === 0 ? "error" : args.priority === 1 ? "warning" : "muted";
+		const titleText = String(args.title).replace(/^\[P\d\]\s*/, "");
+		return new Text(
+			`${theme.fg("toolTitle", theme.bold("report_finding "))}${theme.fg(color, `[${priority}]`)} ${theme.fg("dim", titleText)}`,
+			0,
+			0,
+		);
+	},
+
+	renderResult(result, _options, theme): Component {
+		const { details } = result;
+		if (!details) {
+			const text = result.content[0];
+			return new Text(text?.type === "text" ? text.text : "", 0, 0);
+		}
+
+		const priority = PRIORITY_LABELS[details.priority] ?? "P?";
+		const color = details.priority === 0 ? "error" : details.priority === 1 ? "warning" : "muted";
+		const location = `${details.file_path}:${details.line_start}${details.line_end !== details.line_start ? `-${details.line_end}` : ""}`;
+
+		return new Text(
+			`${theme.fg("success", "✓")} ${theme.fg(color, `[${priority}]`)} ${theme.fg("dim", location)}`,
+			0,
+			0,
+		);
+	},
+};
+
+// submit_review schema
+const SubmitReviewParams = Type.Object({
+	overall_correctness: Type.Union([Type.Literal("correct"), Type.Literal("incorrect")], {
+		description: "Whether the patch is correct (no bugs, tests won't break)",
+	}),
+	explanation: Type.String({
+		description: "1-3 sentence explanation justifying the verdict",
+	}),
+	confidence: Type.Number({
+		minimum: 0,
+		maximum: 1,
+		description: "Overall confidence score 0.0-1.0",
+	}),
+});
+
+interface SubmitReviewDetails {
+	overall_correctness: "correct" | "incorrect";
+	explanation: string;
+	confidence: number;
+}
+
+export const submitReviewTool: AgentTool<typeof SubmitReviewParams, SubmitReviewDetails, Theme> = {
+	name: "submit_review",
+	label: "Submit Review",
+	description: "Submit the final review verdict. Call this after all findings have been reported.",
+	parameters: SubmitReviewParams,
+	hidden: true,
+
+	async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
+		const { overall_correctness, explanation, confidence } = params;
+
+		let summary = `## Review Summary\n\n`;
+		summary += `**Verdict:** ${overall_correctness === "correct" ? "✓ Patch is correct" : "✗ Patch is incorrect"}\n`;
+		summary += `**Confidence:** ${(confidence * 100).toFixed(0)}%\n\n`;
+		summary += explanation;
+
+		return {
+			content: [{ type: "text", text: summary }],
+			details: { overall_correctness, explanation, confidence },
+		};
+	},
+
+	renderCall(args, theme): Component {
+		const verdict = args.overall_correctness === "correct" ? "correct" : "incorrect";
+		const color = args.overall_correctness === "correct" ? "success" : "error";
+		return new Text(
+			`${theme.fg("toolTitle", theme.bold("submit_review "))}${theme.fg(color, verdict)} ${theme.fg("dim", `(${((args.confidence as number) * 100).toFixed(0)}%)`)}`,
+			0,
+			0,
+		);
+	},
+
+	renderResult(result, { expanded }, theme): Component {
+		const { details } = result;
+		if (!details) {
+			const text = result.content[0];
+			return new Text(text?.type === "text" ? text.text : "", 0, 0);
+		}
+
+		const container = new Container();
+		const verdictColor = details.overall_correctness === "correct" ? "success" : "error";
+		const verdictIcon = details.overall_correctness === "correct" ? "✓" : "✗";
+
+		container.addChild(
+			new Text(
+				`${theme.fg(verdictColor, verdictIcon)} Patch is ${theme.fg(verdictColor, details.overall_correctness)} ${theme.fg("dim", `(${(details.confidence * 100).toFixed(0)}% confidence)`)}`,
+				0,
+				0,
+			),
+		);
+
+		if (expanded) {
+			container.addChild(new Spacer(1));
+			container.addChild(new Text(theme.fg("dim", details.explanation), 0, 0));
+		}
+
+		return container;
+	},
+};
+
+export function createReportFindingTool(): AgentTool<typeof ReportFindingParams, ReportFindingDetails, Theme> {
+	return reportFindingTool;
+}
+
+export function createSubmitReviewTool(): AgentTool<typeof SubmitReviewParams, SubmitReviewDetails, Theme> {
+	return submitReviewTool;
+}
+
+// Re-export types for external use
+export type { ReportFindingDetails, SubmitReviewDetails };
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Subprocess tool handlers - registered for extraction/rendering in task tool
+// ─────────────────────────────────────────────────────────────────────────────
+
+import path from "node:path";
+import { subprocessToolRegistry } from "./task/subprocess-tool-registry";
+
+// Register report_finding handler
+subprocessToolRegistry.register<ReportFindingDetails>("report_finding", {
+	extractData: (event) => event.result?.details as ReportFindingDetails | undefined,
+
+	renderInline: (data, theme) => {
+		const priority = PRIORITY_LABELS[data.priority] ?? "P?";
+		const color = data.priority === 0 ? "error" : data.priority === 1 ? "warning" : "muted";
+		const titleText = data.title.replace(/^\[P\d\]\s*/, "");
+		const loc = `${path.basename(data.file_path)}:${data.line_start}`;
+		return new Text(`${theme.fg(color, `[${priority}]`)} ${titleText} ${theme.fg("dim", loc)}`, 0, 0);
+	},
+
+	renderFinal: (allData, theme, expanded) => {
+		const container = new Container();
+		const displayCount = expanded ? allData.length : Math.min(3, allData.length);
+
+		for (let i = 0; i < displayCount; i++) {
+			const data = allData[i];
+			const priority = PRIORITY_LABELS[data.priority] ?? "P?";
+			const color = data.priority === 0 ? "error" : data.priority === 1 ? "warning" : "muted";
+			const titleText = data.title.replace(/^\[P\d\]\s*/, "");
+			const loc = `${path.basename(data.file_path)}:${data.line_start}`;
+
+			container.addChild(
+				new Text(`  ${theme.fg(color, `[${priority}]`)} ${titleText} ${theme.fg("dim", loc)}`, 0, 0),
+			);
+
+			if (expanded && data.body) {
+				container.addChild(new Text(`    ${theme.fg("dim", data.body)}`, 0, 0));
+			}
+		}
+
+		if (allData.length > displayCount) {
+			container.addChild(new Text(theme.fg("dim", `  ... ${allData.length - displayCount} more findings`), 0, 0));
+		}
+
+		return container;
+	},
+});
+
+// Register submit_review handler
+subprocessToolRegistry.register<SubmitReviewDetails>("submit_review", {
+	extractData: (event) => event.result?.details as SubmitReviewDetails | undefined,
+
+	// Terminate subprocess after review is submitted
+	shouldTerminate: () => true,
+
+	renderInline: (data, theme) => {
+		const verdictColor = data.overall_correctness === "correct" ? "success" : "error";
+		const verdictIcon = data.overall_correctness === "correct" ? "✓" : "✗";
+		return new Text(
+			`${theme.fg(verdictColor, verdictIcon)} Review: ${theme.fg(verdictColor, data.overall_correctness)} (${(data.confidence * 100).toFixed(0)}%)`,
+			0,
+			0,
+		);
+	},
+
+	// Note: renderFinal is NOT used for submit_review - we use the combined
+	// renderReviewResult in render.ts to show verdict + findings together
+});

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

@@ -8,7 +8,7 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { fileURLToPath } from "node:url";
-import type { AgentDefinition, AgentSource } from "./types.js";
+import type { AgentDefinition, AgentSource } from "./types";
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const BUNDLED_AGENTS_DIR = path.join(__dirname, "bundled-agents");

package/src/core/tools/task/bundled-agents/explore.md

@@ -2,7 +2,7 @@
 name: explore
 description: Fast read-only codebase scout that returns compressed context for handoff
 tools: read, grep, glob, ls, bash
-model: claude-haiku-4-5, haiku, flash, mini
+model: pi/smol, haiku, flash, mini
 ---
 
 You are a file search specialist and codebase scout. Quickly investigate a codebase and return structured findings that another agent can use without re-reading everything.