@oh-my-pi/pi-coding-agent 15.6.0 → 15.7.0

package/src/tui/output-block.ts

@@ -15,8 +15,81 @@ export interface OutputBlockOptions {
 	sections?: Array<{ label?: string; lines: string[] }>;
 	width: number;
 	applyBg?: boolean;
+	/** Animate the border with a sweeping dark segment (pending/running state). */
+	animate?: boolean;
 }
 
+const BORDER_SHIMMER_TICK_MS = 50;
+/** Duration of one full clockwise lap around the border, in ms. Fixed so a box
+ * growing (new output line) or resizing only nudges the segment proportionally
+ * instead of teleporting it. */
+const BORDER_LAP_MS = 4000;
+/** Length, in border cells, of the moving segment. */
+const BORDER_SEGMENT_LEN = 8;
+
+/**
+ * Monotonic frame counter for animated borders. Quantized coarse enough to
+ * coalesce multiple render passes inside one frame, fine enough to advance on
+ * every spinner interval so cached blocks re-render while the segment travels.
+ */
+export function borderShimmerTick(): number {
+	return Math.floor(Date.now() / BORDER_SHIMMER_TICK_MS);
+}
+
+/** Ease-in-out so the segment decelerates into and accelerates out of corners. */
+function easeInOutQuad(t: number): number {
+	return t < 0.5 ? 2 * t * t : 1 - (-2 * t + 2) ** 2 / 2;
+}
+
+/**
+ * Perimeter index of the moving segment's head for a box of inner width `W` and
+ * height `H` at time `now`. The lap is split across the four edges in proportion
+ * to their length (so the average speed is uniform) and each edge is eased, for a
+ * deliberate, non-linear glide that slows at every corner. Position is derived
+ * from the wall clock against a fixed lap duration, so a perimeter change (new
+ * row / resize) shifts the head by at most a cell or two — no reset.
+ */
+export function borderSegmentHead(W: number, H: number, now: number): number {
+	const P = 2 * W + 2 * H - 4;
+	if (P <= 0) return 0;
+	// Edge cell counts, clockwise from top-left: top, right, bottom, left.
+	const edgeLens = [W, H - 1, W - 1, H - 2];
+	const t = (((now % BORDER_LAP_MS) + BORDER_LAP_MS) % BORDER_LAP_MS) / BORDER_LAP_MS;
+	let acc = 0;
+	let start = 0;
+	for (let i = 0; i < 4; i++) {
+		const len = edgeLens[i]!;
+		const frac = len / P;
+		if (len > 0 && t < acc + frac) {
+			const lf = (t - acc) / frac;
+			return (start + Math.floor(easeInOutQuad(lf) * len)) % P;
+		}
+		acc += frac;
+		start += len;
+	}
+	return P - 1;
+}
+
+/**
+ * Scale a truecolor foreground escape toward black by `factor`. Returns
+ * undefined for 256-color escapes (no RGB to scale) so callers fall back to a
+ * dimmer theme color.
+ */
+function darkenFgAnsi(ansi: string, factor: number): string | undefined {
+	const m = /38;2;(\d+);(\d+);(\d+)/.exec(ansi);
+	if (!m) return undefined;
+	const r = Math.round(Number(m[1]) * factor);
+	const g = Math.round(Number(m[2]) * factor);
+	const b = Math.round(Number(m[3]) * factor);
+	return `\x1b[38;2;${r};${g};${b}m`;
+}
+
+type BlockRow =
+	| { kind: "bar"; leftChar: string; rightChar: string; label?: string; meta?: string }
+	| { kind: "bottom"; leftChar: string; rightChar: string }
+	| { kind: "content"; inner: string }
+	| { kind: "sixel"; raw: string };
+
 export function renderOutputBlock(options: OutputBlockOptions, theme: Theme): string[] {
 	const { header, headerMeta, state, sections = [], width, applyBg = true } = options;
 	const h = theme.boxSharp.horizontal;
@@ -46,62 +119,148 @@ export function renderOutputBlock(options: OutputBlockOptions, theme: Theme): st
 		};
 	})();
 
-	const buildBarLine = (leftChar: string, rightChar: string, label?: string, meta?: string): string => {
-		const left = border(`${leftChar}${cap}`);
-		const right = border(rightChar);
-		if (lineWidth <= 0) return left + right;
-		const labelText = [label, meta].filter(Boolean).join(theme.sep.dot);
-		const rawLabel = labelText ? ` ${labelText} ` : " ";
-		const leftWidth = visibleWidth(left);
-		const rightWidth = visibleWidth(right);
-		const maxLabelWidth = Math.max(0, lineWidth - leftWidth - rightWidth);
-		const trimmedLabel = truncateToWidth(rawLabel, maxLabelWidth);
-		const labelWidth = visibleWidth(trimmedLabel);
-		const fillCount = Math.max(0, lineWidth - leftWidth - labelWidth - rightWidth);
-		return `${left}${trimmedLabel}${border(h.repeat(fillCount))}${right}`;
-	};
-
-	const contentPrefix = border(`${v} `);
-	const contentSuffix = border(v);
-	const contentWidth = Math.max(0, lineWidth - visibleWidth(contentPrefix) - visibleWidth(contentSuffix));
-	const lines: string[] = [];
+	const contentWidth = Math.max(0, lineWidth - visibleWidth(`${v} `) - visibleWidth(v));
 
-	lines.push(
-		padToWidth(buildBarLine(theme.boxSharp.topLeft, theme.boxSharp.topRight, header, headerMeta), lineWidth, bgFn),
-	);
+	// ── Layout pass: collect row descriptors so the border perimeter length is
+	// known before the moving segment is positioned. ──
+	const rows: BlockRow[] = [];
+	rows.push({
+		kind: "bar",
+		leftChar: theme.boxSharp.topLeft,
+		rightChar: theme.boxSharp.topRight,
+		label: header,
+		meta: headerMeta,
+	});
 
-	const hasSections = sections.length > 0;
-	const normalizedSections = hasSections ? sections : [{ lines: [] }];
-
-	for (let i = 0; i < normalizedSections.length; i++) {
-		const section = normalizedSections[i];
+	const normalizedSections = sections.length > 0 ? sections : [{ lines: [] as string[] }];
+	for (const section of normalizedSections) {
 		if (section.label) {
-			lines.push(
-				padToWidth(buildBarLine(theme.boxSharp.teeRight, theme.boxSharp.teeLeft, section.label), lineWidth, bgFn),
-			);
+			rows.push({
+				kind: "bar",
+				leftChar: theme.boxSharp.teeRight,
+				rightChar: theme.boxSharp.teeLeft,
+				label: section.label,
+			});
 		}
 		const allLines = section.lines.flatMap(l => l.split("\n"));
 		const sixelLineMask = TERMINAL.imageProtocol === ImageProtocol.Sixel ? getSixelLineMask(allLines) : undefined;
 		for (let lineIndex = 0; lineIndex < allLines.length; lineIndex++) {
 			const line = allLines[lineIndex]!;
 			if (sixelLineMask?.[lineIndex]) {
-				lines.push(line);
+				rows.push({ kind: "sixel", raw: line });
 				continue;
 			}
 			const wrappedLines = wrapTextWithAnsi(line.trimEnd(), contentWidth);
 			for (const wrappedLine of wrappedLines) {
 				const innerPadding = padding(Math.max(0, contentWidth - visibleWidth(wrappedLine)));
-				const fullLine = `${contentPrefix}${wrappedLine}${innerPadding}${contentSuffix}`;
-				lines.push(padToWidth(fullLine, lineWidth, bgFn));
+				rows.push({ kind: "content", inner: `${wrappedLine}${innerPadding}` });
 			}
 		}
 	}
 
-	const bottomLeft = border(`${theme.boxSharp.bottomLeft}${cap}`);
-	const bottomRight = border(theme.boxSharp.bottomRight);
-	const bottomFillCount = Math.max(0, lineWidth - visibleWidth(bottomLeft) - visibleWidth(bottomRight));
-	const bottomLine = `${bottomLeft}${border(h.repeat(bottomFillCount))}${bottomRight}`;
-	lines.push(padToWidth(bottomLine, lineWidth, bgFn));
+	rows.push({ kind: "bottom", leftChar: theme.boxSharp.bottomLeft, rightChar: theme.boxSharp.bottomRight });
+
+	const H = rows.length;
+	const W = lineWidth;
+	const animate = (options.animate ?? false) && (state === "running" || state === "pending") && W >= 2 && H >= 2;
+
+	// ── Segment geometry: one dark run travels the outer edge clockwise,
+	// top → right → bottom → left → top. ──
+	const P = animate ? 2 * W + 2 * H - 4 : 0;
+	const segLen = Math.min(BORDER_SEGMENT_LEN, P);
+	const head = animate ? borderSegmentHead(W, H, Date.now()) : 0;
+	const segAnsi = animate ? (darkenFgAnsi(theme.getFgAnsi(borderColor), 0.4) ?? theme.getFgAnsi("borderMuted")) : "";
+	const seg = (text: string) => `${segAnsi}${text}\x1b[39m`;
+
+	// Perimeter index of border cell (row r, col c), clockwise from top-left.
+	const perimIndex = (r: number, c: number): number => {
+		if (r === 0) return c;
+		if (c === W - 1) return W - 1 + r;
+		if (r === H - 1) return W - 1 + (H - 1) + (W - 1 - c);
+		return W - 1 + (H - 1) + (W - 1) + (H - 1 - r);
+	};
+	const isLit = (idx: number): boolean => (((idx - head) % P) + P) % P < segLen;
+	// Color a run of border glyphs starting at (row r, col startCol), grouping
+	// consecutive same-state cells so each run emits a single escape pair.
+	const colorEdge = (glyphs: string, r: number, startCol: number): string => {
+		let out = "";
+		let runLit: boolean | null = null;
+		let buf = "";
+		for (let i = 0; i < glyphs.length; i++) {
+			const lit = isLit(perimIndex(r, startCol + i));
+			if (lit !== runLit) {
+				if (runLit !== null) out += (runLit ? seg : border)(buf);
+				buf = "";
+				runLit = lit;
+			}
+			buf += glyphs[i];
+		}
+		if (runLit !== null) out += (runLit ? seg : border)(buf);
+		return out;
+	};
+
+	const renderBar = (
+		row: { leftChar: string; rightChar: string; label?: string; meta?: string },
+		r: number,
+	): string => {
+		const leftGlyphs = `${row.leftChar}${cap}`;
+		const rightGlyph = row.rightChar;
+		if (lineWidth <= 0) return border(leftGlyphs) + border(rightGlyph);
+		const labelText = [row.label, row.meta].filter(Boolean).join(theme.sep.dot);
+		const rawLabel = labelText ? ` ${labelText} ` : " ";
+		const leftWidth = visibleWidth(leftGlyphs);
+		const rightWidth = visibleWidth(rightGlyph);
+		const maxLabelWidth = Math.max(0, lineWidth - leftWidth - rightWidth);
+		const trimmedLabel = truncateToWidth(rawLabel, maxLabelWidth);
+		const labelWidth = visibleWidth(trimmedLabel);
+		const fillCount = Math.max(0, lineWidth - leftWidth - labelWidth - rightWidth);
+		const fillGlyphs = h.repeat(fillCount);
+		if (!animate) {
+			return `${border(leftGlyphs)}${trimmedLabel}${border(fillGlyphs)}${border(rightGlyph)}`;
+		}
+		if (r === 0 || r === H - 1) {
+			// Top/bottom edge: the whole horizontal run lies on the perimeter.
+			const leftStr = colorEdge(leftGlyphs, r, 0);
+			const fillStr = colorEdge(fillGlyphs, r, leftWidth + labelWidth);
+			const rightStr = colorEdge(rightGlyph, r, lineWidth - rightWidth);
+			return `${leftStr}${trimmedLabel}${fillStr}${rightStr}`;
+		}
+		// Interior separator: only the first/last cell sit on the outer edge.
+		return `${colorEdge(row.leftChar, r, 0)}${border(cap)}${trimmedLabel}${border(fillGlyphs)}${colorEdge(rightGlyph, r, lineWidth - rightWidth)}`;
+	};
+
+	const renderBottom = (row: { leftChar: string; rightChar: string }, r: number): string => {
+		const leftGlyphs = `${row.leftChar}${cap}`;
+		const rightGlyph = row.rightChar;
+		const fillCount = Math.max(0, lineWidth - visibleWidth(leftGlyphs) - visibleWidth(rightGlyph));
+		const fillGlyphs = h.repeat(fillCount);
+		if (!animate) return `${border(leftGlyphs)}${border(fillGlyphs)}${border(rightGlyph)}`;
+		const leftStr = colorEdge(leftGlyphs, r, 0);
+		const fillStr = colorEdge(fillGlyphs, r, visibleWidth(leftGlyphs));
+		const rightStr = colorEdge(rightGlyph, r, lineWidth - visibleWidth(rightGlyph));
+		return `${leftStr}${fillStr}${rightStr}`;
+	};
+
+	const renderContent = (inner: string, r: number): string => {
+		if (!animate) return `${border(`${v} `)}${inner}${border(v)}`;
+		return `${colorEdge(v, r, 0)} ${inner}${colorEdge(v, r, lineWidth - 1)}`;
+	};
+
+	const lines: string[] = [];
+	for (let r = 0; r < H; r++) {
+		const row = rows[r]!;
+		if (row.kind === "sixel") {
+			lines.push(row.raw);
+			continue;
+		}
+		const line =
+			row.kind === "bar"
+				? renderBar(row, r)
+				: row.kind === "bottom"
+					? renderBottom(row, r)
+					: renderContent(row.inner, r);
+		lines.push(padToWidth(line, lineWidth, bgFn));
+	}
 
 	return lines;
 }
@@ -137,6 +296,8 @@ export class CachedOutputBlock {
 		h.optional(options.headerMeta);
 		h.optional(options.state);
 		h.bool(options.applyBg ?? true);
+		h.bool(options.animate ?? false);
+		if (options.animate) h.u32(borderShimmerTick());
 		if (options.sections) {
 			for (const s of options.sections) {
 				h.optional(s.label);

package/dist/types/tools/recipe/index.d.ts

@@ -1,46 +0,0 @@
-import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
-import type { Component } from "@oh-my-pi/pi-tui";
-import * as z from "zod/v4";
-import type { RenderResultOptions } from "../../extensibility/custom-tools/types";
-import type { Theme } from "../../modes/theme/theme";
-import type { ToolSession } from "..";
-import { type BashRenderContext, type BashToolDetails } from "../bash";
-import { type RecipeRenderArgs } from "./render";
-import { type DetectedRunner } from "./runner";
-declare const recipeSchema: z.ZodObject<{
-    op: z.ZodString;
-}, z.core.$strict>;
-type RecipeParams = z.infer<typeof recipeSchema>;
-type RecipeRenderResult = {
-    content: Array<{
-        type: string;
-        text?: string;
-    }>;
-    details?: BashToolDetails;
-    isError?: boolean;
-};
-export declare class RecipeTool implements AgentTool<typeof recipeSchema, BashToolDetails, Theme> {
-    #private;
-    readonly name = "recipe";
-    readonly label = "Run";
-    readonly approval: "exec";
-    readonly description: string;
-    readonly parameters: z.ZodObject<{
-        op: z.ZodString;
-    }, z.core.$strict>;
-    readonly strict = true;
-    readonly concurrency = "exclusive";
-    readonly loadMode = "discoverable";
-    readonly summary = "Execute a saved bash recipe (multi-step shell command preset)";
-    readonly mergeCallAndResult = true;
-    readonly inline = true;
-    readonly renderCall: (args: RecipeRenderArgs, options: RenderResultOptions, uiTheme: Theme) => Component;
-    readonly renderResult: (result: RecipeRenderResult, options: RenderResultOptions & {
-        renderContext?: BashRenderContext;
-    }, uiTheme: Theme, args?: RecipeRenderArgs) => Component;
-    constructor(session: ToolSession, runners: DetectedRunner[]);
-    static createIf(session: ToolSession): Promise<RecipeTool | null>;
-    execute(toolCallId: string, { op }: RecipeParams, signal?: AbortSignal, onUpdate?: AgentToolUpdateCallback<BashToolDetails>, ctx?: AgentToolContext): Promise<AgentToolResult<BashToolDetails>>;
-}
-export * from "./runner";
-export { tasksFromCargoMetadata } from "./runners/cargo";

package/dist/types/tools/recipe/render.d.ts

@@ -1,36 +0,0 @@
-import type { DetectedRunner } from "./runner";
-export interface RecipeRenderArgs {
-    op?: string;
-    __partialJson?: string;
-    [key: string]: unknown;
-}
-export declare function createRecipeToolRenderer(runners: DetectedRunner[]): {
-    renderCall(args: RecipeRenderArgs, options: import("../..").RenderResultOptions, uiTheme: import("../..").Theme): import("@oh-my-pi/pi-tui").Component;
-    renderResult(result: {
-        content: {
-            type: string;
-            text?: string;
-        }[];
-        details?: import("..").BashToolDetails;
-        isError?: boolean;
-    }, options: import("../..").RenderResultOptions & {
-        renderContext?: import("..").BashRenderContext;
-    }, uiTheme: import("../..").Theme, args?: RecipeRenderArgs | undefined): import("@oh-my-pi/pi-tui").Component;
-    mergeCallAndResult: boolean;
-    inline: boolean;
-};
-export declare const recipeToolRenderer: {
-    renderCall(args: RecipeRenderArgs, options: import("../..").RenderResultOptions, uiTheme: import("../..").Theme): import("@oh-my-pi/pi-tui").Component;
-    renderResult(result: {
-        content: {
-            type: string;
-            text?: string;
-        }[];
-        details?: import("..").BashToolDetails;
-        isError?: boolean;
-    }, options: import("../..").RenderResultOptions & {
-        renderContext?: import("..").BashRenderContext;
-    }, uiTheme: import("../..").Theme, args?: RecipeRenderArgs | undefined): import("@oh-my-pi/pi-tui").Component;
-    mergeCallAndResult: boolean;
-    inline: boolean;
-};

package/dist/types/tools/recipe/runner.d.ts

@@ -1,60 +0,0 @@
-export interface RunnerTask {
-    name: string;
-    doc?: string;
-    /** Parameter names only; used for the `name foo bar` signature line in the description. */
-    parameters: string[];
-    /** Override for this specific task, e.g. `cargo run --package crate --bin`. */
-    commandPrefix?: string;
-    /** Token passed to the runner command; defaults to `name`. Used when display names are namespaced. */
-    commandName?: string;
-    /** Working directory for the task, relative to the session cwd; absent means the runner's root cwd. */
-    cwd?: string;
-}
-export interface DetectedRunner {
-    id: string;
-    label: string;
-    /** Resolved shell prefix, e.g. "just" or "bun run" or "make". */
-    commandPrefix: string;
-    tasks: RunnerTask[];
-}
-export interface TaskRunner {
-    id: string;
-    label: string;
-    /**
-     * Probe `cwd` for the manifest, the binary, and the task list.
-     * Returns null when this runner does not apply.
-     */
-    detect(cwd: string): Promise<DetectedRunner | null>;
-}
-interface PromptTaskModel {
-    name: string;
-    paramSig?: string;
-    command?: string;
-    doc?: string;
-    cwd?: string;
-}
-interface PromptRunnerModel {
-    id: string;
-    label: string;
-    commandPrefix: string;
-    tasks: PromptTaskModel[];
-    hiddenTaskCount?: number;
-}
-export interface RecipePromptModel {
-    [key: string]: unknown;
-    hasMultipleRunners: boolean;
-    ambiguityExampleRunner?: string;
-    ambiguityExampleTask?: string;
-    runners: PromptRunnerModel[];
-}
-export interface ResolvedTask {
-    command: string;
-    cwd?: string;
-}
-export declare function resolveCommand(op: string, runners: DetectedRunner[]): ResolvedTask;
-export declare function resolveTaskFromOp(op: string | undefined, runners: DetectedRunner[]): ResolvedTask | undefined;
-export declare function commandFromOp(op: string | undefined, runners: DetectedRunner[]): string | undefined;
-export declare function cwdFromOp(op: string | undefined, runners: DetectedRunner[]): string | undefined;
-export declare function titleFromOp(op: string | undefined, runners: DetectedRunner[]): string;
-export declare function buildPromptModel(runners: DetectedRunner[]): RecipePromptModel;
-export {};

package/dist/types/tools/recipe/runners/cargo.d.ts

@@ -1,16 +0,0 @@
-import type { RunnerTask, TaskRunner } from "../runner";
-export interface CargoMetadataTarget {
-    kind?: string[];
-    name?: string;
-}
-export interface CargoMetadataPackage {
-    id?: string;
-    name?: string;
-    targets?: CargoMetadataTarget[];
-}
-export interface CargoMetadata {
-    packages?: CargoMetadataPackage[];
-    workspace_members?: string[];
-}
-export declare function tasksFromCargoMetadata(metadata: CargoMetadata): RunnerTask[];
-export declare const cargoRunner: TaskRunner;

package/dist/types/tools/recipe/runners/index.d.ts

@@ -1,2 +0,0 @@
-import type { TaskRunner } from "../runner";
-export declare const RUNNERS: TaskRunner[];

package/dist/types/tools/recipe/runners/just.d.ts

@@ -1,2 +0,0 @@
-import type { TaskRunner } from "../runner";
-export declare const justRunner: TaskRunner;

package/dist/types/tools/recipe/runners/make.d.ts

@@ -1,2 +0,0 @@
-import type { TaskRunner } from "../runner";
-export declare const makeRunner: TaskRunner;

package/dist/types/tools/recipe/runners/pkg.d.ts

@@ -1,2 +0,0 @@
-import type { TaskRunner } from "../runner";
-export declare const pkgRunner: TaskRunner;

package/dist/types/tools/recipe/runners/task.d.ts

@@ -1,2 +0,0 @@
-import type { TaskRunner } from "../runner";
-export declare const taskRunner: TaskRunner;

package/src/prompts/tools/recipe.md

@@ -1,16 +0,0 @@
-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 cwd}} in `{{cwd}}`{{/if}}){{/if}}
-{{/each}}
-</runner>
-{{/each}}

package/src/tools/recipe/index.ts

@@ -1,81 +0,0 @@
-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 * as z from "zod/v4";
-import type { RenderResultOptions } from "../../extensibility/custom-tools/types";
-import type { Theme } from "../../modes/theme/theme";
-import recipeDescription from "../../prompts/tools/recipe.md" with { type: "text" };
-import type { ToolSession } from "..";
-import { type BashRenderContext, BashTool, type BashToolDetails } from "../bash";
-import { createRecipeToolRenderer, type RecipeRenderArgs } from "./render";
-import { buildPromptModel, type DetectedRunner, resolveCommand } from "./runner";
-import { RUNNERS } from "./runners";
-
-const recipeSchema = z
-	.object({
-		op: z.string().describe('task name and args, e.g. "test" or "build --release"'),
-	})
-	.strict();
-type RecipeParams = z.infer<typeof recipeSchema>;
-
-type RecipeRenderResult = {
-	content: Array<{ type: string; text?: string }>;
-	details?: BashToolDetails;
-	isError?: boolean;
-};
-
-export class RecipeTool implements AgentTool<typeof recipeSchema, BashToolDetails, Theme> {
-	readonly name = "recipe";
-	readonly label = "Run";
-	readonly approval = "exec" as const;
-	readonly description: string;
-	readonly parameters = recipeSchema;
-	readonly strict = true;
-	readonly concurrency = "exclusive";
-	readonly loadMode = "discoverable";
-	readonly summary = "Execute a saved bash recipe (multi-step shell command preset)";
-	readonly mergeCallAndResult = true;
-	readonly inline = true;
-	readonly renderCall: (args: RecipeRenderArgs, options: RenderResultOptions, uiTheme: Theme) => Component;
-	readonly renderResult: (
-		result: RecipeRenderResult,
-		options: RenderResultOptions & { renderContext?: BashRenderContext },
-		uiTheme: Theme,
-		args?: RecipeRenderArgs,
-	) => Component;
-
-	readonly #bash: BashTool;
-	readonly #runners: DetectedRunner[];
-
-	constructor(session: ToolSession, runners: DetectedRunner[]) {
-		this.#runners = runners;
-		this.#bash = new BashTool(session);
-		this.description = prompt.render(recipeDescription, buildPromptModel(runners));
-		const renderer = createRecipeToolRenderer(runners);
-		this.renderCall = renderer.renderCall;
-		this.renderResult = renderer.renderResult;
-	}
-
-	static async createIf(session: ToolSession): Promise<RecipeTool | null> {
-		if (!session.settings.get("recipe.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 RecipeTool(session, detected);
-	}
-
-	async execute(
-		toolCallId: string,
-		{ op }: RecipeParams,
-		signal?: AbortSignal,
-		onUpdate?: AgentToolUpdateCallback<BashToolDetails>,
-		ctx?: AgentToolContext,
-	): Promise<AgentToolResult<BashToolDetails>> {
-		const { command, cwd } = resolveCommand(op, this.#runners);
-		return await this.#bash.execute(toolCallId, { command, cwd }, signal, onUpdate, ctx);
-	}
-}
-
-export * from "./runner";
-export { tasksFromCargoMetadata } from "./runners/cargo";

package/src/tools/recipe/render.ts

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