@oh-my-pi/pi-coding-agent 15.0.0 → 15.0.2

package/src/tools/render-utils.ts

@@ -9,10 +9,12 @@ import * as os from "node:os";
 import * as path from "node:path";
 import type { ToolCallContext } from "@oh-my-pi/pi-agent-core";
 import type { Ellipsis } from "@oh-my-pi/pi-natives";
+import type { Component } from "@oh-my-pi/pi-tui";
 import { replaceTabs, truncateToWidth } from "@oh-my-pi/pi-tui";
 import { pluralize } from "@oh-my-pi/pi-utils";
 import { settings } from "../config/settings";
 import type { Theme } from "../modes/theme/theme";
+import { Hasher } from "../tui/utils";
 import { formatDimensionNote, type ResizedImage } from "../utils/image-resize";
 
 export { Ellipsis } from "@oh-my-pi/pi-natives";
@@ -642,6 +644,96 @@ export function formatParseErrors(errors: string[]): string[] {
 	return [header, ...capped.map(err => `- ${err}`)];
 }
 
+// =============================================================================
+// Renderer helpers shared by search / find / ast tools
+// =============================================================================
+
+/**
+ * Group `rawLines` by blank-line separators, mirroring the historical search /
+ * ast-grep / ast-edit renderer behavior: if any blank line is present, splits on
+ * runs of blank lines; otherwise collapses non-empty lines into a single group.
+ */
+export function splitGroupsByBlankLine(rawLines: string[]): string[][] {
+	const hasSeparators = rawLines.some(line => line.trim().length === 0);
+	const groups: string[][] = [];
+	if (hasSeparators) {
+		let current: string[] = [];
+		for (const line of rawLines) {
+			if (line.trim().length === 0) {
+				if (current.length > 0) {
+					groups.push(current);
+					current = [];
+				}
+				continue;
+			}
+			current.push(line);
+		}
+		if (current.length > 0) groups.push(current);
+	} else {
+		const nonEmpty = rawLines.filter(line => line.trim().length > 0);
+		if (nonEmpty.length > 0) {
+			groups.push(nonEmpty);
+		}
+	}
+	return groups;
+}
+
+/**
+ * Standard width+expand keyed render cache used by every search-style tool
+ * renderer. `compute` re-runs only when the cache key changes; the returned
+ * Component is the canonical `{ render, invalidate }` pair.
+ */
+export function createCachedComponent(
+	getExpanded: () => boolean,
+	compute: (width: number, expanded: boolean) => string[],
+): Component {
+	let cached: { key: bigint; lines: string[] } | undefined;
+	return {
+		render(width: number): string[] {
+			const expanded = getExpanded();
+			const key = new Hasher().bool(expanded).u32(width).digest();
+			if (cached?.key === key) return cached.lines;
+			const lines = compute(width, expanded);
+			cached = { key, lines };
+			return lines;
+		},
+		invalidate() {
+			cached = undefined;
+		},
+	};
+}
+
+/**
+ * Append the indented bullet list of parse errors (capped at
+ * {@link PARSE_ERRORS_LIMIT}) to `lines`, with an overflow summary line if the
+ * total exceeds the cap. No-op when `parseErrors` is empty.
+ */
+export function appendParseErrorsBulletList(
+	lines: string[],
+	parseErrors: readonly string[] | undefined,
+	theme: Theme,
+): void {
+	if (!parseErrors || parseErrors.length === 0) return;
+	const capped = parseErrors.slice(0, PARSE_ERRORS_LIMIT);
+	for (const err of capped) {
+		lines.push(theme.fg("warning", `  - ${err}`));
+	}
+	if (parseErrors.length > PARSE_ERRORS_LIMIT) {
+		lines.push(theme.fg("dim", `  … ${parseErrors.length - PARSE_ERRORS_LIMIT} more`));
+	}
+}
+
+/**
+ * Human-readable summary string for the parse-issues count, capped by
+ * {@link PARSE_ERRORS_LIMIT}.
+ */
+export function formatParseErrorsCountLabel(parseErrors: readonly string[]): string {
+	const total = parseErrors.length;
+	return total > PARSE_ERRORS_LIMIT
+		? `${PARSE_ERRORS_LIMIT} / ${total} parse issues`
+		: `${total} parse issue${total !== 1 ? "s" : ""}`;
+}
+
 // =============================================================================
 // LSP Batching
 // =============================================================================

package/src/tools/renderers.ts

@@ -6,6 +6,7 @@
 import type { Component } from "@oh-my-pi/pi-tui";
 import { editToolRenderer } from "../edit/renderer";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
+import { goalToolRenderer } from "../goals/tools/goal-tool";
 import { lspToolRenderer } from "../lsp/render";
 import type { Theme } from "../modes/theme/theme";
 import { taskToolRenderer } from "../task/render";
@@ -68,6 +69,7 @@ export const toolRenderers: Record<string, ToolRenderer> = {
 	task: taskToolRenderer as ToolRenderer,
 	todo_write: todoWriteToolRenderer as ToolRenderer,
 	github: githubToolRenderer as ToolRenderer,
+	goal: goalToolRenderer as ToolRenderer,
 	web_search: webSearchToolRenderer as ToolRenderer,
 	write: writeToolRenderer as ToolRenderer,
 };

package/src/tools/resolve.ts

@@ -14,6 +14,12 @@ import { ToolError } from "./tool-errors";
 const resolveSchema = Type.Object({
 	action: Type.Union([Type.Literal("apply"), Type.Literal("discard")]),
 	reason: Type.String({ description: "reason for action", examples: ["approved by user"] }),
+	extra: Type.Optional(
+		Type.Record(Type.String(), Type.Unknown(), {
+			description:
+				'Free-form metadata interpreted by the resolving tool (e.g. plan-mode approval requires `{ title: "<PLAN_TITLE>" }`).',
+		}),
+	),
 });
 
 type ResolveParams = Static<typeof resolveSchema>;
@@ -21,17 +27,12 @@ type ResolveParams = Static<typeof resolveSchema>;
 export interface ResolveToolDetails {
 	action: "apply" | "discard";
 	reason: string;
+	extra?: Record<string, unknown>;
 	sourceToolName?: string;
 	label?: string;
 	sourceResultDetails?: unknown;
 }
 
-function resolveReasonPreview(reason?: string): string | undefined {
-	const trimmed = reason?.trim();
-	if (!trimmed) return undefined;
-	return truncateToWidth(trimmed, 72, Ellipsis.Omit);
-}
-
 /**
  * Queue a resolve-protocol handler on the tool-choice queue. Forces the next
  * LLM call to invoke the hidden `resolve` tool, wraps the caller's apply/reject
@@ -47,49 +48,25 @@ export function queueResolveHandler(
 	options: {
 		label: string;
 		sourceToolName: string;
-		apply(reason: string): Promise<AgentToolResult<unknown>>;
-		reject?(reason: string): Promise<AgentToolResult<unknown> | undefined>;
+		apply(reason: string, extra?: Record<string, unknown>): Promise<AgentToolResult<unknown>>;
+		reject?(reason: string, extra?: Record<string, unknown>): Promise<AgentToolResult<unknown> | undefined>;
 	},
 ): void {
 	const queue = session.getToolChoiceQueue?.();
 	const forced = session.buildToolChoice?.("resolve");
 	if (!queue || !forced || typeof forced === "string") return;
 
-	const detailsFor = (params: ResolveParams): ResolveToolDetails => ({
-		action: params.action,
-		reason: params.reason,
-		sourceToolName: options.sourceToolName,
-		label: options.label,
-	});
-
 	queue.pushOnce(forced, {
 		label: `pending-action:${options.sourceToolName}`,
 		now: true,
 		onRejected: () => "requeue",
-		onInvoked: async (input: unknown) => {
-			const params = input as ResolveParams;
-			const withResolveDetails = (result: AgentToolResult<unknown>): AgentToolResult<ResolveToolDetails> => ({
-				...result,
-				details: {
-					...detailsFor(params),
-					...(result.details != null ? { sourceResultDetails: result.details } : {}),
-				},
-			});
-			if (params.action === "apply") {
-				const result = await options.apply(params.reason);
-				return withResolveDetails(result);
-			}
-			if (params.action === "discard" && options.reject != null) {
-				const result = await options.reject(params.reason);
-				if (result != null) {
-					return withResolveDetails(result);
-				}
-			}
-			return {
-				content: [{ type: "text" as const, text: `Discarded: ${options.label}. Reason: ${params.reason}` }],
-				details: detailsFor(params),
-			};
-		},
+		onInvoked: async (input: unknown) =>
+			runResolveInvocation(input as ResolveParams, {
+				sourceToolName: options.sourceToolName,
+				label: options.label,
+				apply: options.apply,
+				reject: options.reject,
+			}),
 	});
 
 	session.steer?.({
@@ -103,6 +80,57 @@ export function queueResolveHandler(
 	});
 }
 
+/**
+ * Shared invocation runner used by both queued (in-flight) handlers and
+ * standing handlers (e.g. plan-mode approval). Discriminates on action,
+ * routes through the caller's apply/reject, and wraps the resulting tool
+ * payload with `ResolveToolDetails` so the renderer and event-controller
+ * see a consistent shape.
+ */
+export async function runResolveInvocation(
+	params: ResolveParams,
+	options: {
+		sourceToolName: string;
+		label: string;
+		apply(reason: string, extra?: Record<string, unknown>): Promise<AgentToolResult<unknown>>;
+		reject?(reason: string, extra?: Record<string, unknown>): Promise<AgentToolResult<unknown> | undefined>;
+	},
+): Promise<AgentToolResult<ResolveToolDetails>> {
+	const baseDetails: ResolveToolDetails = {
+		action: params.action,
+		reason: params.reason,
+		sourceToolName: options.sourceToolName,
+		label: options.label,
+		...(params.extra != null ? { extra: params.extra } : {}),
+	};
+	if (params.action === "apply") {
+		const result = await options.apply(params.reason, params.extra);
+		return {
+			...result,
+			details: {
+				...baseDetails,
+				...(result.details != null ? { sourceResultDetails: result.details } : {}),
+			},
+		};
+	}
+	if (params.action === "discard" && options.reject != null) {
+		const result = await options.reject(params.reason, params.extra);
+		if (result != null) {
+			return {
+				...result,
+				details: {
+					...baseDetails,
+					...(result.details != null ? { sourceResultDetails: result.details } : {}),
+				},
+			};
+		}
+	}
+	return {
+		content: [{ type: "text" as const, text: `Discarded: ${options.label}. Reason: ${params.reason}` }],
+		details: baseDetails,
+	};
+}
+
 export class ResolveTool implements AgentTool<typeof resolveSchema, ResolveToolDetails> {
 	readonly name = "resolve";
 	readonly label = "Resolve";
@@ -112,10 +140,9 @@ export class ResolveTool implements AgentTool<typeof resolveSchema, ResolveToolD
 	readonly strict = true;
 	readonly intent = (args: Partial<ResolveParams>) => {
 		if (args.action === "discard") {
-			return args.reason ? `discarding: ${args.reason}` : "aiscarding changes";
-		} else {
-			return args.reason ? `accepting: ${args.reason}` : "accepting changes";
+			return args.reason ? `discarding: ${args.reason}` : "discarding changes";
 		}
+		return args.reason ? `accepting: ${args.reason}` : "accepting changes";
 	};
 
 	constructor(private readonly session: ToolSession) {
@@ -130,7 +157,7 @@ export class ResolveTool implements AgentTool<typeof resolveSchema, ResolveToolD
 		_context?: AgentToolContext,
 	): Promise<AgentToolResult<ResolveToolDetails>> {
 		return untilAborted(signal, async () => {
-			const invoker = this.session.peekQueueInvoker?.();
+			const invoker = this.session.peekQueueInvoker?.() ?? this.session.peekStandingResolveHandler?.();
 			if (!invoker) {
 				throw new ToolError("No pending action to resolve. Nothing to apply or discard.");
 			}
@@ -142,7 +169,8 @@ export class ResolveTool implements AgentTool<typeof resolveSchema, ResolveToolD
 
 export const resolveToolRenderer = {
 	renderCall(args: ResolveParams, _options: RenderResultOptions, uiTheme: Theme): Component {
-		const reason = resolveReasonPreview(args.reason);
+		const reasonTrimmed = args.reason?.trim();
+		const reason = reasonTrimmed ? truncateToWidth(reasonTrimmed, 72, Ellipsis.Omit) : undefined;
 		const text = renderStatusLine(
 			{
 				icon: "pending",