@oh-my-pi/pi-coding-agent 14.5.6 → 14.5.8

package/src/modes/types.ts

@@ -86,6 +86,8 @@ export interface InteractiveModeContext {
 	toolOutputExpanded: boolean;
 	todoExpanded: boolean;
 	planModeEnabled: boolean;
+	loopModeEnabled: boolean;
+	loopPrompt?: string;
 	planModePlanFilePath?: string;
 	hideThinkingBlock: boolean;
 	pendingImages: ImageContent[];
@@ -106,6 +108,7 @@ export interface InteractiveModeContext {
 	unsubscribe?: () => void;
 	onInputCallback?: (input: SubmittedUserInput) => void;
 	optimisticUserMessageSignature: string | undefined;
+	locallySubmittedUserSignatures: Set<string>;
 	lastSigintTime: number;
 	lastEscapeTime: number;
 	shutdownRequested: boolean;
@@ -233,6 +236,8 @@ export interface InteractiveModeContext {
 	openExternalEditor(): void;
 	registerExtensionShortcuts(): void;
 	handlePlanModeCommand(initialPrompt?: string): Promise<void>;
+	handleLoopCommand(prompt?: string): Promise<void>;
+	disableLoopMode(options?: { silent?: boolean }): void;
 	handleExitPlanModeTool(details: ExitPlanModeDetails): Promise<void>;
 
 	// Hook UI methods

package/src/prompts/tools/run-command.md

@@ -0,0 +1,16 @@
+Run a recipe / script / target from the project's task runners.
+
+<instruction>
+- `op` is a single string: task name plus any args, e.g. `{op: "test"}` or `{op: "build --release"}`.
+- In monorepos, package and Cargo target tasks are namespaced with `/`, e.g. `{op: "pkg-a/test"}` or `{op: "crate/bin/server"}`.
+{{#if hasMultipleRunners}}- When the same task name exists in more than one runner, prefix with the runner id, e.g. `{op: "{{ambiguityExampleRunner}}:{{ambiguityExampleTask}}"}`. The available runner ids are: {{#each runners}}`{{id}}`{{#unless @last}}, {{/unless}}{{/each}}.
+{{/if}}- Runs in the session's cwd. Output and exit code are returned in the same shape as `bash`.
+</instruction>
+
+{{#each runners}}
+<runner id="{{id}}" label="{{label}}" command="{{commandPrefix}}">
+{{#each tasks}}
+- `{{name}}{{#if paramSig}} {{paramSig}}{{/if}}`{{#if doc}} — {{doc}}{{/if}}{{#if command}} (`{{command}}`){{/if}}
+{{/each}}
+</runner>
+{{/each}}

package/src/slash-commands/builtin-registry.ts

@@ -121,6 +121,16 @@ const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<BuiltinSlashCommandSpec> = [
 			runtime.ctx.editor.setText("");
 		},
 	},
+	{
+		name: "loop",
+		description: "Loop the agent: re-submit the same prompt every time it yields (Esc to stop)",
+		inlineHint: "<prompt>",
+		allowArgs: true,
+		handle: async (command, runtime) => {
+			await runtime.ctx.handleLoopCommand(command.args || undefined);
+			runtime.ctx.editor.setText("");
+		},
+	},
 	{
 		name: "model",
 		aliases: ["models"],

package/src/tools/bash.ts

@@ -222,15 +222,6 @@ function extractPartialBashEnv(partialJson: string | undefined): Record<string,
 	return Object.keys(env).length > 0 ? env : undefined;
 }
 
-function getBashEnvForDisplay(args: BashRenderArgs): Record<string, string> | undefined {
-	// During streaming, partial-json parsing often does not surface env values until the object closes.
-	// Recover them from the raw JSON buffer so the pending bash preview can show `NAME="..." cmd` immediately,
-	// instead of rendering only the command and making the env assignment appear at the very end.
-	const partialEnv = extractPartialBashEnv(args.__partialJson);
-	if (partialEnv && args.env) return { ...partialEnv, ...args.env };
-	return args.env ?? partialEnv;
-}
-
 function formatTimeoutClampNotice(requestedTimeoutSec: number, effectiveTimeoutSec: number): string | undefined {
 	return requestedTimeoutSec !== effectiveTimeoutSec
 		? `Timeout clamped to ${effectiveTimeoutSec}s (requested ${requestedTimeoutSec}s; allowed range ${TOOL_TIMEOUTS.bash.min}-${TOOL_TIMEOUTS.bash.max}s).`
@@ -688,8 +679,7 @@ export class BashTool implements AgentTool<BashToolSchema, BashToolDetails> {
 // =============================================================================
 // TUI Renderer
 // =============================================================================
-
-interface BashRenderArgs {
+export interface BashRenderArgs {
 	command?: string;
 	env?: Record<string, string>;
 	timeout?: number;
@@ -698,7 +688,7 @@ interface BashRenderArgs {
 	[key: string]: unknown;
 }
 
-interface BashRenderContext {
+export interface BashRenderContext {
 	/** Raw output text */
 	output?: string;
 	/** Whether output came from artifact storage */
@@ -711,7 +701,29 @@ interface BashRenderContext {
 	timeout?: number;
 }
 
-function formatBashCommand(args: BashRenderArgs): string {
+export interface ShellRendererConfig<TArgs> {
+	resolveTitle: (args: TArgs | undefined, options: RenderResultOptions) => string;
+	resolveCommand?: (args: TArgs | undefined) => string | undefined;
+	resolveCwd?: (args: TArgs | undefined) => string | undefined;
+	resolveEnv?: (args: TArgs | undefined) => Record<string, string> | undefined;
+}
+
+function getPartialJson<TArgs>(args: TArgs | undefined): string | undefined {
+	if (!args || typeof args !== "object" || !("__partialJson" in args)) return undefined;
+	const value = (args as { __partialJson?: unknown }).__partialJson;
+	return typeof value === "string" ? value : undefined;
+}
+
+export function getBashEnvForDisplay(args: BashRenderArgs): Record<string, string> | undefined {
+	// During streaming, partial-json parsing often does not surface env values until the object closes.
+	// Recover them from the raw JSON buffer so the pending bash preview can show `NAME="..." cmd` immediately,
+	// instead of rendering only the command and making the env assignment appear at the very end.
+	const partialEnv = extractPartialBashEnv(args.__partialJson);
+	if (partialEnv && args.env) return { ...partialEnv, ...args.env };
+	return args.env ?? partialEnv;
+}
+
+export function formatBashCommand(args: BashRenderArgs): string {
 	const command = replaceTabs(args.command || "…");
 	const prompt = "$";
 	const cwd = getProjectDir();
@@ -720,113 +732,135 @@ function formatBashCommand(args: BashRenderArgs): string {
 	return displayWorkdir ? `${prompt} cd ${displayWorkdir} && ${renderedCommand}` : `${prompt} ${renderedCommand}`;
 }
 
-export const bashToolRenderer = {
-	renderCall(args: BashRenderArgs, _options: RenderResultOptions, uiTheme: Theme): Component {
-		const cmdText = formatBashCommand(args);
-		const text = renderStatusLine({ icon: "pending", title: "Bash", description: cmdText }, uiTheme);
-		return new Text(text, 0, 0);
-	},
-
-	renderResult(
-		result: {
-			content: Array<{ type: string; text?: string }>;
-			details?: BashToolDetails;
-			isError?: boolean;
+function toBashRenderArgs<TArgs>(args: TArgs | undefined, config: ShellRendererConfig<TArgs>): BashRenderArgs {
+	return {
+		command: config.resolveCommand?.(args),
+		cwd: config.resolveCwd?.(args),
+		env: config.resolveEnv?.(args),
+		__partialJson: getPartialJson(args),
+	};
+}
+
+export function createShellRenderer<TArgs>(config: ShellRendererConfig<TArgs>) {
+	return {
+		renderCall(args: TArgs, options: RenderResultOptions, uiTheme: Theme): Component {
+			const renderArgs = toBashRenderArgs(args, config);
+			const cmdText = formatBashCommand(renderArgs);
+			const title = config.resolveTitle(args, options);
+			const text = renderStatusLine({ icon: "pending", title, description: cmdText }, uiTheme);
+			return new Text(text, 0, 0);
 		},
-		options: RenderResultOptions & { renderContext?: BashRenderContext },
-		uiTheme: Theme,
-		args?: BashRenderArgs,
-	): Component {
-		const cmdText = args ? formatBashCommand(args) : undefined;
-		const isError = result.isError === true;
-		const icon = options.isPartial ? "pending" : isError ? "error" : "success";
-		const header = renderStatusLine({ icon, title: "Bash" }, uiTheme);
-		const details = result.details;
-		const outputBlock = new CachedOutputBlock();
 
-		return {
-			render: (width: number): string[] => {
-				// REACTIVE: read mutable options at render time
-				const { renderContext } = options;
-				const expanded = renderContext?.expanded ?? options.expanded;
-				const previewLines = renderContext?.previewLines ?? BASH_DEFAULT_PREVIEW_LINES;
-
-				// Get output from context (preferred) or fall back to result content
-				const output = renderContext?.output ?? result.content?.find(c => c.type === "text")?.text ?? "";
-				const displayOutput = output.trimEnd();
-				const showingFullOutput = expanded && renderContext?.isFullOutput === true;
-
-				// Build truncation warning
-				const timeoutSeconds = details?.timeoutSeconds ?? renderContext?.timeout;
-				const requestedTimeoutSeconds = details?.requestedTimeoutSeconds;
-				const timeoutLabel =
-					typeof timeoutSeconds === "number"
-						? requestedTimeoutSeconds !== undefined && requestedTimeoutSeconds !== timeoutSeconds
-							? `Timeout: ${timeoutSeconds}s (requested ${requestedTimeoutSeconds}s clamped)`
-							: `Timeout: ${timeoutSeconds}s`
-						: undefined;
-				const timeoutLine =
-					timeoutLabel !== undefined
-						? uiTheme.fg("dim", `${uiTheme.format.bracketLeft}${timeoutLabel}${uiTheme.format.bracketRight}`)
-						: undefined;
-				let warningLine: string | undefined;
-				if (details?.meta?.truncation && !showingFullOutput) {
-					warningLine = formatStyledTruncationWarning(details.meta, uiTheme) ?? undefined;
-				}
+		renderResult(
+			result: {
+				content: Array<{ type: string; text?: string }>;
+				details?: BashToolDetails;
+				isError?: boolean;
+			},
+			options: RenderResultOptions & { renderContext?: BashRenderContext },
+			uiTheme: Theme,
+			args?: TArgs,
+		): Component {
+			const renderArgs = toBashRenderArgs(args, config);
+			const cmdText = args ? formatBashCommand(renderArgs) : undefined;
+			const isError = result.isError === true;
+			const icon = options.isPartial ? "pending" : isError ? "error" : "success";
+			const title = config.resolveTitle(args, options);
+			const header = renderStatusLine({ icon, title }, uiTheme);
+			const details = result.details;
+			const outputBlock = new CachedOutputBlock();
+
+			return {
+				render: (width: number): string[] => {
+					// REACTIVE: read mutable options at render time
+					const { renderContext } = options;
+					const expanded = renderContext?.expanded ?? options.expanded;
+					const previewLines = renderContext?.previewLines ?? BASH_DEFAULT_PREVIEW_LINES;
+
+					// Get output from context (preferred) or fall back to result content
+					const output = renderContext?.output ?? result.content?.find(c => c.type === "text")?.text ?? "";
+					const displayOutput = output.trimEnd();
+					const showingFullOutput = expanded && renderContext?.isFullOutput === true;
+
+					// Build truncation warning
+					const timeoutSeconds = details?.timeoutSeconds ?? renderContext?.timeout;
+					const requestedTimeoutSeconds = details?.requestedTimeoutSeconds;
+					const timeoutLabel =
+						typeof timeoutSeconds === "number"
+							? requestedTimeoutSeconds !== undefined && requestedTimeoutSeconds !== timeoutSeconds
+								? `Timeout: ${timeoutSeconds}s (requested ${requestedTimeoutSeconds}s clamped)`
+								: `Timeout: ${timeoutSeconds}s`
+							: undefined;
+					const timeoutLine =
+						timeoutLabel !== undefined
+							? uiTheme.fg("dim", `${uiTheme.format.bracketLeft}${timeoutLabel}${uiTheme.format.bracketRight}`)
+							: undefined;
+					let warningLine: string | undefined;
+					if (details?.meta?.truncation && !showingFullOutput) {
+						warningLine = formatStyledTruncationWarning(details.meta, uiTheme) ?? undefined;
+					}
 
-				const outputLines: string[] = [];
-				const hasOutput = displayOutput.trim().length > 0;
-				const rawOutputLines = displayOutput.split("\n");
-				const sixelLineMask =
-					TERMINAL.imageProtocol === ImageProtocol.Sixel ? getSixelLineMask(rawOutputLines) : undefined;
-				const hasSixelOutput = sixelLineMask?.some(Boolean) ?? false;
-				if (hasOutput) {
-					if (hasSixelOutput) {
-						outputLines.push(
-							...rawOutputLines.map((line, index) =>
-								sixelLineMask?.[index] ? line : uiTheme.fg("toolOutput", replaceTabs(line)),
-							),
-						);
-					} else if (expanded) {
-						outputLines.push(...rawOutputLines.map(line => uiTheme.fg("toolOutput", replaceTabs(line))));
-					} else {
-						const styledOutput = rawOutputLines
-							.map(line => uiTheme.fg("toolOutput", replaceTabs(line)))
-							.join("\n");
-						const textContent = styledOutput;
-						const result = truncateToVisualLines(textContent, previewLines, width);
-						if (result.skippedCount > 0) {
+					const outputLines: string[] = [];
+					const hasOutput = displayOutput.trim().length > 0;
+					const rawOutputLines = displayOutput.split("\n");
+					const sixelLineMask =
+						TERMINAL.imageProtocol === ImageProtocol.Sixel ? getSixelLineMask(rawOutputLines) : undefined;
+					const hasSixelOutput = sixelLineMask?.some(Boolean) ?? false;
+					if (hasOutput) {
+						if (hasSixelOutput) {
 							outputLines.push(
-								uiTheme.fg(
-									"dim",
-									`… (${result.skippedCount} earlier lines, showing ${result.visualLines.length} of ${result.skippedCount + result.visualLines.length}) (ctrl+o to expand)`,
+								...rawOutputLines.map((line, index) =>
+									sixelLineMask?.[index] ? line : uiTheme.fg("toolOutput", replaceTabs(line)),
 								),
 							);
+						} else if (expanded) {
+							outputLines.push(...rawOutputLines.map(line => uiTheme.fg("toolOutput", replaceTabs(line))));
+						} else {
+							const styledOutput = rawOutputLines
+								.map(line => uiTheme.fg("toolOutput", replaceTabs(line)))
+								.join("\n");
+							const textContent = styledOutput;
+							const result = truncateToVisualLines(textContent, previewLines, width);
+							if (result.skippedCount > 0) {
+								outputLines.push(
+									uiTheme.fg(
+										"dim",
+										`… (${result.skippedCount} earlier lines, showing ${result.visualLines.length} of ${result.skippedCount + result.visualLines.length}) (ctrl+o to expand)`,
+									),
+								);
+							}
+							outputLines.push(...result.visualLines);
 						}
-						outputLines.push(...result.visualLines);
 					}
-				}
-				if (timeoutLine) outputLines.push(timeoutLine);
-				if (warningLine) outputLines.push(warningLine);
-
-				return outputBlock.render(
-					{
-						header,
-						state: options.isPartial ? "pending" : isError ? "error" : "success",
-						sections: [
-							{ lines: cmdText ? [uiTheme.fg("dim", cmdText)] : [] },
-							{ label: uiTheme.fg("toolTitle", "Output"), lines: outputLines },
-						],
-						width,
-					},
-					uiTheme,
-				);
-			},
-			invalidate: () => {
-				outputBlock.invalidate();
-			},
-		};
-	},
-	mergeCallAndResult: true,
-	inline: true,
-};
+					if (timeoutLine) outputLines.push(timeoutLine);
+					if (warningLine) outputLines.push(warningLine);
+
+					return outputBlock.render(
+						{
+							header,
+							state: options.isPartial ? "pending" : isError ? "error" : "success",
+							sections: [
+								{ lines: cmdText ? [uiTheme.fg("dim", cmdText)] : [] },
+								{ label: uiTheme.fg("toolTitle", "Output"), lines: outputLines },
+							],
+							width,
+						},
+						uiTheme,
+					);
+				},
+				invalidate: () => {
+					outputBlock.invalidate();
+				},
+			};
+		},
+		mergeCallAndResult: true,
+		inline: true,
+	};
+}
+
+export const bashToolRenderer = createShellRenderer<BashRenderArgs>({
+	resolveTitle: () => "Bash",
+	resolveCommand: args => args?.command,
+	resolveCwd: args => args?.cwd,
+	resolveEnv: args => args?.env,
+});

package/src/tools/index.ts

@@ -41,6 +41,7 @@ import { RenderMermaidTool } from "./render-mermaid";
 import { createReportToolIssueTool, isAutoQaEnabled } from "./report-tool-issue";
 import { ResolveTool } from "./resolve";
 import { reportFindingTool } from "./review";
+import { RunCommandTool } from "./run-command";
 import { SearchTool } from "./search";
 import { SearchToolBm25Tool } from "./search-tool-bm25";
 import { loadSshTool } from "./ssh";
@@ -79,6 +80,7 @@ export * from "./render-mermaid";
 export * from "./report-tool-issue";
 export * from "./resolve";
 export * from "./review";
+export * from "./run-command";
 export * from "./search";
 export * from "./search-tool-bm25";
 export * from "./ssh";
@@ -224,6 +226,7 @@ export const BUILTIN_TOOLS: Record<string, ToolFactory> = {
 	rewind: RewindTool.createIf,
 	task: TaskTool.create,
 	job: JobTool.createIf,
+	run_command: RunCommandTool.createIf,
 	irc: IrcTool.createIf,
 	todo_write: s => new TodoWriteTool(s),
 	web_search: s => new WebSearchTool(s),
@@ -370,6 +373,13 @@ export async function createTools(session: ToolSession, toolNames?: string[]): P
 		) {
 			requestedTools.push("ast_edit");
 		}
+		if (
+			requestedTools.includes("bash") &&
+			!requestedTools.includes("run_command") &&
+			session.settings.get("runCommand.enabled")
+		) {
+			requestedTools.push("run_command");
+		}
 	}
 	const allTools: Record<string, ToolFactory> = { ...BUILTIN_TOOLS, ...HIDDEN_TOOLS };
 	const isToolAllowed = (name: string) => {
@@ -392,6 +402,7 @@ export async function createTools(session: ToolSession, toolNames?: string[]): P
 		if (name === "browser") return session.settings.get("browser.enabled");
 		if (name === "checkpoint" || name === "rewind") return session.settings.get("checkpoint.enabled");
 		if (name === "irc") return session.settings.get("irc.enabled");
+		if (name === "run_command") return session.settings.get("runCommand.enabled");
 		if (name === "task") {
 			const maxDepth = session.settings.get("task.maxRecursionDepth") ?? 2;
 			const currentDepth = session.taskDepth ?? 0;

package/src/tools/renderers.ts

@@ -24,6 +24,7 @@ import { notebookToolRenderer } from "./notebook";
 import { pythonToolRenderer } from "./python";
 import { readToolRenderer } from "./read";
 import { resolveToolRenderer } from "./resolve";
+import { runCommandToolRenderer } from "./run-command/render";
 import { searchToolRenderer } from "./search";
 import { searchToolBm25Renderer } from "./search-tool-bm25";
 import { sshToolRenderer } from "./ssh";
@@ -48,6 +49,7 @@ export const toolRenderers: Record<string, ToolRenderer> = {
 	ast_grep: astGrepToolRenderer as ToolRenderer,
 	ast_edit: astEditToolRenderer as ToolRenderer,
 	bash: bashToolRenderer as ToolRenderer,
+	run_command: runCommandToolRenderer as ToolRenderer,
 	debug: debugToolRenderer as ToolRenderer,
 	python: pythonToolRenderer as ToolRenderer,
 	calc: calculatorToolRenderer as ToolRenderer,

package/src/tools/run-command/index.ts

@@ -0,0 +1,80 @@
+import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
+import type { Component } from "@oh-my-pi/pi-tui";
+import { prompt } from "@oh-my-pi/pi-utils";
+import { type Static, Type } from "@sinclair/typebox";
+import type { RenderResultOptions } from "../../extensibility/custom-tools/types";
+import type { Theme } from "../../modes/theme/theme";
+import runCommandDescription from "../../prompts/tools/run-command.md" with { type: "text" };
+import type { ToolSession } from "..";
+import { type BashRenderContext, BashTool, type BashToolDetails } from "../bash";
+import { createRunCommandToolRenderer, type RunCommandRenderArgs } from "./render";
+import { buildPromptModel, type DetectedRunner, resolveCommand } from "./runner";
+import { RUNNERS } from "./runners";
+
+const runCommandSchema = Type.Object({
+	op: Type.String({
+		description: 'task name and args, e.g. "test" or "build --release"',
+		examples: ["test", "build --release", "pkg:test --watch"],
+	}),
+});
+
+type RunCommandParams = Static<typeof runCommandSchema>;
+
+type RunCommandRenderResult = {
+	content: Array<{ type: string; text?: string }>;
+	details?: BashToolDetails;
+	isError?: boolean;
+};
+
+export class RunCommandTool implements AgentTool<typeof runCommandSchema, BashToolDetails, Theme> {
+	readonly name = "run_command";
+	readonly label = "Run";
+	readonly description: string;
+	readonly parameters = runCommandSchema;
+	readonly strict = true;
+	readonly concurrency = "exclusive";
+	readonly mergeCallAndResult = true;
+	readonly inline = true;
+	readonly renderCall: (args: RunCommandRenderArgs, options: RenderResultOptions, uiTheme: Theme) => Component;
+	readonly renderResult: (
+		result: RunCommandRenderResult,
+		options: RenderResultOptions & { renderContext?: BashRenderContext },
+		uiTheme: Theme,
+		args?: RunCommandRenderArgs,
+	) => Component;
+
+	readonly #bash: BashTool;
+	readonly #runners: DetectedRunner[];
+
+	constructor(session: ToolSession, runners: DetectedRunner[]) {
+		this.#runners = runners;
+		this.#bash = new BashTool(session);
+		this.description = prompt.render(runCommandDescription, buildPromptModel(runners));
+		const renderer = createRunCommandToolRenderer(runners);
+		this.renderCall = renderer.renderCall;
+		this.renderResult = renderer.renderResult;
+	}
+
+	static async createIf(session: ToolSession): Promise<RunCommandTool | null> {
+		if (!session.settings.get("runCommand.enabled")) return null;
+		const detected = (await Promise.all(RUNNERS.map(runner => runner.detect(session.cwd)))).filter(
+			(runner): runner is DetectedRunner => runner !== null && runner.tasks.length > 0,
+		);
+		if (detected.length === 0) return null;
+		return new RunCommandTool(session, detected);
+	}
+
+	async execute(
+		toolCallId: string,
+		{ op }: RunCommandParams,
+		signal?: AbortSignal,
+		onUpdate?: AgentToolUpdateCallback<BashToolDetails>,
+		ctx?: AgentToolContext,
+	): Promise<AgentToolResult<BashToolDetails>> {
+		const command = resolveCommand(op, this.#runners);
+		return await this.#bash.execute(toolCallId, { command }, signal, onUpdate, ctx);
+	}
+}
+
+export * from "./runner";
+export { tasksFromCargoMetadata } from "./runners/cargo";

package/src/tools/run-command/render.ts

@@ -0,0 +1,18 @@
+import { createShellRenderer } from "../bash";
+import type { DetectedRunner } from "./runner";
+import { commandFromOp, titleFromOp } from "./runner";
+
+export interface RunCommandRenderArgs {
+	op?: string;
+	__partialJson?: string;
+	[key: string]: unknown;
+}
+
+export function createRunCommandToolRenderer(runners: DetectedRunner[]) {
+	return createShellRenderer<RunCommandRenderArgs>({
+		resolveTitle: args => titleFromOp(args?.op, runners),
+		resolveCommand: args => commandFromOp(args?.op, runners),
+	});
+}
+
+export const runCommandToolRenderer = createRunCommandToolRenderer([]);