decorated-pi 0.2.1 → 0.3.0

package/README.md

@@ -1,82 +1,76 @@
 # decorated-pi
 
-`decorated-pi` is a Pi extension that adds safety gates, LSP tools, image/compaction model helpers, smarter `@` file search, dynamic subdirectory `AGENTS.md` loading, and a few workflow quality-of-life improvements.
+`decorated-pi` is a Pi extension that adds stronger edit tool, safety gates, LSP tools, image/compaction model helpers, smarter `@` file search, dynamic subdirectory `AGENTS.md` loading, and a few workflow quality-of-life improvements.
+
+## Install
+
+```bash
+pi install npm:decorated-pi
+pi install git:github.com/lcwecker/decorated-pi
+pi install /path/to/decorated-pi
+```
 
 ## Features
 
-### 1. Safety Layer
+### 1. Patch Tool
 
-- **Dangerous bash guard**
-  - asks for confirmation on destructive commands such as:
-    - `rm`
-    - `sudo`
-    - `svn commit/revert`
-    - `git reset/restore/clean/push/revert`
-    - `npm publish`
-    - `>` / `1>` / `2>` / `&>` / `tee` overwrite existing files
-  - Hints the agent to use `edit` instead of `write` on non-empty files
-- **Protected paths**
-  - Blocks read/write access (via `write`/`edit`/`read` tools or `cat`/`head`/`tail`/`grep`/`rg` etc. bash commands) to sensitive locations such as `.env`, `.git/`, `.ssh/`, `*.pem`, `*.key`, etc.
-- **Secret redaction**
-  - Dual-layer detection: 40+ known-format patterns (AWS, GitHub, OpenAI, etc.) + Adjusted Shannon Entropy analysis for unknown formats. Based on [opencode-secrets-protect](https://github.com/jscheel/opencode-secrets-protect) (MIT)
+Replaces Pi's built-in `edit` / `write` with a stronger `patch` tool:
+
+- **anchor mechanism** — narrows the search range by specifying a unique string that appears before `old_str`, preventing mismatches in files with repeated patterns
+- **mtime tracking** — records file modification time on `read`, rejects `patch` if the file changed since last read, preventing blind or stale edits
+- **explicit overwrite** — offer atomic `overwrite: true` mode for overwrite files or full-file creation to prevent unintened overwrite
 
 ### 2. Smart `@` File Search
 
-Replaces Pi's default file search with a faster project-aware search strategy:
+Replaces Pi's default file search with a faster, project-aware search strategy:
 
-- Uses `git ls-files` in git repos
-- Falls back to `fd` outside git repos
-- Caches results for 10 seconds
-- Scores primarily on **filename match quality**, not full-path fuzziness
-- Penalizes hidden/cache/build directories
-- Hides hidden paths from empty-query results
+- Uses project-aware file discovery
+- Prioritizes filename-based matches for more intuitive results
+- Reduces clutter from hidden, cache, and build directories
+- Keeps default suggestions focused on visible project files
 
 ### 3. LSP Tool Suite
 
-Based on [@spences10/pi-lsp](https://github.com/spences10/my-pi/tree/main/packages/pi-lsp) by Scott Spence (MIT License), with additions:
+Based on [@spences10/pi-lsp](https://github.com/spences10/my-pi/tree/main/packages/pi-lsp), with major additions:
 
-- C/C++ (clangd) and Lua support
+- C/C++ and Lua support
 - `lsp_find_symbol`, `lsp_rename`, multi-file support merged into `lsp_diagnostics`
 - Force-sync on `didChange` (no stale diagnostics)
 
-Registered tools:
-
-- `lsp_diagnostics`
-- `lsp_find_symbol`
-- `lsp_hover`
-- `lsp_definition`
-- `lsp_references`
-- `lsp_document_symbols`
-- `lsp_rename`
-
-Supported languages:
-
-- c/cpp
-- go
-- java
-- lua
-- python
-- ruby
-- rust
-- svelte
-- typescript
+Supported languages: c/cpp, go, java, lua, python, ruby, rust, svelte, typescript
 
 ### 4. Auxiliary Models (Image + Compact)
 
-Uses cheaper models for auxiliary tasks, configured via `/extend-model`:
+Uses cheaper models for auxiliary tasks, configured via `/dp-model`:
 
 - **Image read fallback** — when the model reads an image file, detects type via magic bytes, calls a configured vision-capable model, and replaces the read result with image analysis text (jpeg, png, gif, webp)
 - **Compact model** — uses a configured model for context compaction (instead of the main model), auto-resumes after compaction.
 
-### 5. Dynamic Subdirectory `AGENTS.md` / `CLAUDE.md`
+### 5. Safety Layer
+
+- **Dangerous bash guard**
+  - asks for confirmation on destructive commands such as:
+    - `rm`
+    - `sudo`
+    - `svn commit/revert`
+    - `git reset/restore/clean/push/revert`
+    - `npm publish`
+    - `>` / `1>` / `2>` / `&>` / `tee` overwrite existing files
+  - Hints the agent to use `edit` instead of `write` on non-empty files
+- **Protected paths**
+  - Blocks read/write access (via `write`/`edit`/`read` tools or `cat`/`head`/`tail`/`grep`/`rg` etc. bash commands) to sensitive locations such as `.env`, `.git/`, `.ssh/`, `*.pem`, `*.key`, etc.
+- **Secret redaction**
+  - Three-layer detection: high-confidence known-format patterns (AWS, GitHub, OpenAI, etc.), config-key regex matching, and adjusted Shannon entropy heuristics for unknown secret-like values.
+  - Based on [opencode-secrets-protect](https://github.com/jscheel/opencode-secrets-protect)
+
+### 6. Dynamic Subdirectory `AGENTS.md` / `CLAUDE.md`
 
 When the agent reads or edits a file:
 
 - discovers `AGENTS.md` / `CLAUDE.md` in the file's directory and ancestor directories
 - injects newly discovered guidance into tool results
-- persists discovered files into the session so they are restored on resume
 
-### 6. Extend Providers
+### 7. Extend Providers
 
 Extend providers are registered via `/login` → "Use a subscription":
 
@@ -86,16 +80,6 @@ Extend providers are registered via `/login` → "Use a subscription":
 | Baidu Qianfan | `qianfan.baidubce.com/v2/coding` |
 | ARK Coding | `ark.cn-beijing.volces.com/api/coding/v3` |
 
-## Install
-
-```bash
-pi install /path/to/decorated-pi #local
-pi install npm:decorated-pi #npm
-pi install git:github.com/lcwecker/decorated-pi #github
-```
-
-Then reload Pi
-
 ## Configuration
 
 Runtime settings are stored in:
@@ -104,6 +88,30 @@ Runtime settings are stored in:
 ~/.pi/agent/decorated-pi.json
 ```
 
+### Module Loading
+
+Modules can be toggled on/off. Changes take effect after `/reload`.
+
+| Module | Default | Effect when disabled |
+| -------- | --------- | --------------------- |
+| `patch` | `true` | Reverts to Pi's built-in `edit` / `write` tools |
+| `safety` | `true` | No command guard, no protected path check, no secret redaction |
+| `lsp` | `true` | All `lsp_*` tools unregistered — no diagnostics, hover, etc. |
+| `smart-at` | `true` | Fallback to Pi's built-in `@` file completion |
+
+Use `/dp-settings` to toggle, or edit the config file directly:
+
+```json
+{
+  "modules": {
+    "patch": true,
+    "safety": true,
+    "lsp": false,
+    "smart-at": true
+  }
+}
+```
+
 ## License
 
 MIT

package/extensions/file-times.ts

@@ -0,0 +1,66 @@
+/**
+ * File mtime tracking for stale-read protection.
+ *
+ * - `read` tool records mtime when the LLM reads a file
+ * - `patch` tool checks mtime before editing — rejects if file changed since last read
+ * - `patch` tool updates mtime after a successful write
+ */
+
+import * as fs from "node:fs";
+import * as path from "node:path";
+
+/** Last-known mtime for each absolute file path (ms since epoch). */
+const readMarkers = new Map<string, number>();
+
+/** Get current file mtime in ms. Throws if file doesn't exist. */
+function getFileMtime(absPath: string): number {
+  const stat = fs.statSync(absPath);
+  return stat.mtimeMs;
+}
+
+/** Record that the LLM has seen the current version of a file.
+ *  Called after `read` tool completes and after `patch` writes. */
+export function recordReadTime(absPath: string): void {
+  if (!fs.existsSync(absPath)) return;
+  readMarkers.set(absPath, getFileMtime(absPath));
+}
+
+/** Check if file has been modified since last read.
+ *  Returns an error message if stale, or undefined if ok to edit. */
+export function checkStaleFile(absPath: string, displayPath: string): string | undefined {
+  // If file doesn't exist on disk, always allow — creating a new file
+  // doesn't require reading it first, and recreating a deleted file is safe.
+  if (!fs.existsSync(absPath)) {
+    return undefined;
+  }
+
+  const lastRead = readMarkers.get(absPath);
+  if (lastRead === undefined) {
+    // File exists but never read — must read first to avoid blind edits
+    return (
+      `File not read yet: ${displayPath}. ` +
+      `Please read the file with the read tool before editing.`
+    );
+  }
+
+  const currentMtime = getFileMtime(absPath);
+  if (currentMtime > lastRead) {
+    return (
+      `File modified since last read: ${displayPath}. ` +
+      `Please re-read the file with the read tool before editing.`
+    );
+  }
+
+  return undefined;
+}
+
+/** Clear all tracked file times (e.g., on session start). */
+export function clearReadMarkers(): void {
+  readMarkers.clear();
+}
+
+/** Resolve a relative path to absolute (for consistent map keys). */
+export function resolveAbsolutePath(cwd: string, filePath: string): string {
+  if (path.isAbsolute(filePath)) return path.normalize(filePath);
+  return path.normalize(path.resolve(cwd, filePath));
+}

package/extensions/index.ts

@@ -3,24 +3,30 @@
  */
 
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import { setupSafety } from "./safety";
-import { setupExtendModel } from "./extend-model";
+import { setupSafety } from "./safety/index.js";
+import { setupModelIntegration } from "./model-integration";
 import { setupSlash } from "./slash";
 import { setupSubdirAgents } from "./subdir-agents";
 import { setupSessionTitle } from "./session-title";
+import { setupIO } from "./io";
 import { setupGuidance } from "./guidance";
 import { setupLsp } from "./lsp/index";
 import { setupProviders } from "./providers/index";
 import { setupSmartAt } from "./smart-at";
+import { isModuleEnabled } from "./settings";
 
 export default function (pi: ExtensionAPI) {
-  setupSafety(pi);
-  setupExtendModel(pi);
+  // Always loaded — core commands and providers
   setupSlash(pi);
+  setupProviders(pi);
+  setupModelIntegration(pi);
   setupSubdirAgents(pi);
   setupSessionTitle(pi);
   setupGuidance(pi);
-  setupLsp(pi);
-  setupProviders(pi);
-  setupSmartAt(pi);
+
+  // Configurable modules
+  if (isModuleEnabled("patch"))     setupIO(pi);
+  if (isModuleEnabled("safety"))    setupSafety(pi);
+  if (isModuleEnabled("lsp"))       setupLsp(pi);
+  if (isModuleEnabled("smart-at"))  setupSmartAt(pi);
 }

package/extensions/io.ts

@@ -0,0 +1,406 @@
+/**
+ * IO — Replace Pi native edit/write with `patch` tool (single-file)
+ *
+ * Keeps:   read (for stale-read protection via mtime tracking)
+ * Removes: edit, write
+ * Adds:    patch (old_str/new_str exact replacement, single file per call)
+ *
+ * Schema: { path, edits?, overwrite?, new_str? }
+ * Pi’s native parallel tool calls handle multi-file scenarios.
+ *
+ * Stale-read protection:
+ *   - `read` tool records file mtime when LLM reads a file
+ *   - `patch` tool checks: if file mtime > last-read mtime → reject
+ *   - `patch` tool updates mtime after successful write
+ *
+ * TUI Rendering Pitfalls (learned the hard way):
+ *   1. execute() MUST throw errors, NOT return { isError: true }
+ *   2. TUI rendering MUST mirror the edit tool pattern exactly
+ *   3. getPatchHeaderBg: settledError MUST be checked first
+ *   4. renderResult must NOT return the Box
+ *   5. Error text must go INSIDE the Box, not in the result Container
+ *   6. prepareArguments must handle literal newlines in JSON strings
+ */
+
+import { defineTool, isReadToolResult, keyHint, type ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { renderDiff } from "@earendil-works/pi-coding-agent";
+import { Box, Container, Spacer, Text, truncateToWidth } from "@earendil-works/pi-tui";
+import { Type } from "typebox";
+import {
+  applyPatch,
+  formatPatchResult,
+  generatePatchDiff,
+  computePatchPreview,
+  type PatchPreview,
+} from "./patch.js";
+import { recordReadTime, checkStaleFile, clearReadMarkers, resolveAbsolutePath } from "./file-times.js";
+
+// ─── Schema ─────────────────────────────────────────────────────────────────────────
+
+const EditSchema = Type.Object({
+  anchor: Type.Optional(Type.String({
+    description: "Optional unique string that appears BEFORE old_str in the file. Narrows the search range.",
+  })),
+  old_str: Type.String({
+    description: "Exact text to find. Must be unique within the search range. String, not regex.",
+  }),
+  new_str: Type.String({
+    description: "Replacement text. String. Use empty string to delete.",
+  }),
+});
+
+const PatchSchema = Type.Object({
+  path: Type.String({
+    description: "Path to the file to edit (relative or absolute).",
+  }),
+  edits: Type.Optional(Type.Array(EditSchema, {
+    description: "Targeted replacements applied sequentially.",
+  })),
+  overwrite: Type.Optional(Type.Boolean({
+    description: "If true, replace the entire file atomically (write temp → mv).",
+  })),
+  new_str: Type.Optional(Type.String({
+    description: "Entire new file content when overwrite is true.",
+  })),
+});
+
+// ─── Argument repair ───────────────────────────────────────────────────────────────
+
+function fixJsonNewlines(str: string): string {
+  let result = '';
+  let inString = false;
+  let escaped = false;
+  for (let i = 0; i < str.length; i++) {
+    const ch = str[i];
+    if (escaped) { result += ch; escaped = false; continue; }
+    if (ch === '\\') { result += ch; escaped = true; continue; }
+    if (ch === '"') { inString = !inString; result += ch; continue; }
+    if (inString && (ch === '\n' || ch === '\r')) {
+      result += ch === '\n' ? '\\n' : '\\r';
+      continue;
+    }
+    result += ch;
+  }
+  return result;
+}
+
+function jsonParseWithNewlineFix(str: string): any {
+  try { return JSON.parse(str); }
+  catch { try { return JSON.parse(fixJsonNewlines(str)); } catch { return undefined; } }
+}
+
+export function preparePatchArguments(input: any): any {
+  if (!input || typeof input !== "object") return input;
+
+  const args = input as Record<string, any>;
+
+  // Legacy multi-file format: { patches: [{ path, edits }] } → extract first
+  if (Array.isArray(args.patches) && !args.path) {
+    const first = args.patches[0];
+    if (first && typeof first === "object" && first.path) {
+      Object.assign(args, first);
+      delete args.patches;
+    }
+  } else if (typeof args.patches === "string" && !args.path) {
+    try {
+      const parsed = jsonParseWithNewlineFix(args.patches);
+      if (Array.isArray(parsed) && parsed.length > 0 && parsed[0]?.path) {
+        Object.assign(args, parsed[0]);
+        delete args.patches;
+      } else if (parsed && typeof parsed === "object" && parsed.path) {
+        Object.assign(args, parsed);
+        delete args.patches;
+      }
+    } catch { /* keep original */ }
+  }
+
+  // Edits serialized as JSON string
+  if (typeof args.edits === "string") {
+    try {
+      const parsed = jsonParseWithNewlineFix(args.edits);
+      if (Array.isArray(parsed)) args.edits = parsed;
+    } catch { /* keep original */ }
+  }
+
+  // Legacy: top-level old_str/new_str instead of edits array
+  if (typeof args.old_str === "string" && typeof args.new_str === "string") {
+    const edit: any = { old_str: args.old_str, new_str: args.new_str };
+    if (typeof args.anchor === "string") edit.anchor = args.anchor;
+    args.edits = args.edits ? [...args.edits, edit] : [edit];
+    delete args.old_str;
+    delete args.new_str;
+    delete args.anchor;
+  }
+
+  return args;
+}
+
+// ─── TUI rendering ─────────────────────────────────────────────────────────────────
+
+interface PatchCallComponent extends Box {
+  preview?: PatchPreview;
+  previewArgsKey?: string;
+  previewPending?: boolean;
+  settledError: boolean;
+}
+
+function createPatchCallComponent(): PatchCallComponent {
+  return Object.assign(new Box(1, 1, (text: string) => text), {
+    preview: undefined,
+    previewArgsKey: undefined,
+    previewPending: false,
+    settledError: false,
+  });
+}
+
+function getPatchCallComponent(state: any, lastComponent: any): PatchCallComponent {
+  if (lastComponent instanceof Box) {
+    const comp = lastComponent as PatchCallComponent;
+    state.callComponent = comp;
+    return comp;
+  }
+  if (state.callComponent) return state.callComponent;
+  const comp = createPatchCallComponent();
+  state.callComponent = comp;
+  return comp;
+}
+
+function getPatchHeaderBg(component: PatchCallComponent, theme: any) {
+  if (component.settledError) {
+    return (text: string) => theme.bg("toolErrorBg", text);
+  }
+  if (component.preview) {
+    if ("error" in component.preview && component.preview.error) {
+      return (text: string) => theme.bg("toolErrorBg", text);
+    }
+    return (text: string) => theme.bg("toolSuccessBg", text);
+  }
+  return (text: string) => theme.bg("toolPendingBg", text);
+}
+
+function createSingleLineComponent(text: string) {
+  return {
+    render(width: number) {
+      return [truncateToWidth(text, width)];
+    },
+    invalidate() {},
+  };
+}
+
+function appendPatchDiffChildren(parent: Box, body: string, theme: any): void {
+  const rawLines = body.split("\n");
+  let buffer: string[] = [];
+
+  const flush = () => {
+    if (buffer.length === 0) return;
+    parent.addChild(new Text(renderDiff(buffer.join("\n")), 0, 0));
+    buffer = [];
+  };
+
+  for (const line of rawLines) {
+    if (line.startsWith("@@ lines ")) {
+      flush();
+      parent.addChild(createSingleLineComponent(theme.fg("accent", line)) as any);
+      continue;
+    }
+    if (line === "anchors:") {
+      flush();
+      parent.addChild(createSingleLineComponent(theme.fg("accent", line)) as any);
+      continue;
+    }
+    if (line.startsWith("  - ")) {
+      flush();
+      parent.addChild(createSingleLineComponent(theme.fg("accent", line)) as any);
+      continue;
+    }
+    buffer.push(line);
+  }
+
+  flush();
+}
+
+function buildPatchCallComponent(component: PatchCallComponent, args: any, theme: any, expanded = false) {
+  component.setBgFn(getPatchHeaderBg(component, theme));
+  component.clear();
+
+  let label = "";
+  if (args?.path) {
+    label = theme.fg("accent", args.path);
+    if (args.overwrite) {
+      label += theme.fg("warning", " [overwrite]");
+    } else if (args.edits?.length > 0) {
+      label += theme.fg("dim", ` (${args.edits.length} edit${args.edits.length > 1 ? "s" : ""})`);
+    }
+  }
+  const headerText = theme.fg("toolTitle", theme.bold("patch")) + (label ? " " + label : "");
+  component.addChild(new Text(headerText, 0, 0));
+
+  if (component.settledError || !component.preview) return component;
+
+  const preview = component.preview;
+  let body = "";
+  if ("isOverwrite" in preview && preview.isOverwrite && preview.preview) {
+    body = preview.preview;
+  } else if ("diff" in preview && preview.diff) {
+    body = preview.diff;
+  } else if ("error" in preview && preview.error) {
+    component.addChild(new Spacer(1));
+    component.addChild(new Text(theme.fg("error", `  Error: ${preview.error}`), 0, 0));
+    return component;
+  }
+
+  if (!body) return component;
+
+  const lines = body.split("\n");
+  const FOLD_THRESHOLD = 45;
+
+  component.addChild(new Spacer(1));
+  if (lines.length > FOLD_THRESHOLD && !expanded) {
+    // 折叠态: 显示前几行 + 摘要
+    const shown = lines.slice(0, 10).join("\n");
+    const isOverwrite = "isOverwrite" in preview && preview.isOverwrite;
+    if (isOverwrite) {
+      component.addChild(new Text(theme.fg("toolDiffAdded", shown), 0, 0));
+    } else {
+      appendPatchDiffChildren(component, shown, theme);
+    }
+    component.addChild(new Text(
+      theme.fg("dim", `  ... ${lines.length - 10} more lines (`) + keyHint("app.tools.expand", "expand") + theme.fg("dim", ")"),
+      0, 0,
+    ));
+  } else {
+    // 展开态: 完整显示
+    const isOverwrite = "isOverwrite" in preview && preview.isOverwrite;
+    if (isOverwrite) {
+      component.addChild(new Text(theme.fg("toolDiffAdded", body), 0, 0));
+    } else {
+      appendPatchDiffChildren(component, body, theme);
+    }
+  }
+
+  return component;
+}
+
+// ─── Setup ──────────────────────────────────────────────────────────────────────────
+
+export function setupIO(pi: ExtensionAPI) {
+  pi.on("session_start", () => {
+    clearReadMarkers();
+    const active = pi.getActiveTools();
+    pi.setActiveTools(active.filter(t => !["edit", "write"].includes(t)));
+  });
+
+  // Track file read times
+  pi.on("tool_result", (event, ctx) => {
+    if (!isReadToolResult(event)) return;
+    const filePath = event.input?.path;
+    if (typeof filePath !== "string" || !filePath.trim()) return;
+    const cwd: string = ctx.cwd ?? process.cwd();
+    const absPath = resolveAbsolutePath(cwd, filePath);
+    recordReadTime(absPath);
+  });
+
+  pi.registerTool(defineTool({
+    name: "patch",
+    label: "Patch",
+    description: [
+      "Edits a file using exact string replacement, with optional anchor to narrow search.",
+      "When old_str is not unique, add more surrounding context or use anchor to narrow search.",
+      "If possible, prefer anchor for more robust edits. Anchor must be a unique string that appears BEFORE old_str in the file.",
+      "",
+      "Examples:",
+      '  { path: "src/foo.ts", edits: [{ anchor: "function bar() {", old_str: "return x", new_str: "return y" }] }',
+      '  { path: "src/foo.ts", edits: [{ old_str: "return 1", new_str: "return 42" }] }',
+      '  { path: "src/bar.ts", overwrite: true, new_str: "entire file content" }',
+      "Anchor examples (provide enough context to make it unique):",
+      '  prefer "function foo()" over "foo".',
+      '  prefer "class Foo" over "Foo".',
+      '  prefer "## Section Title" in md file edits.',
+    ].join("\n"),
+    promptSnippet: "Edits a file using exact string replacement, with anchor support and overwrite mode.",
+    promptGuidelines: [
+      "Always prefer modifying files with PATCH tool over bash commands or python scripts.",
+      "For full-file replacement, always use patch tool to prevent unintended edits or data loss.",
+    ],
+    parameters: PatchSchema,
+    renderShell: "self",
+    prepareArguments: preparePatchArguments,
+    execute: async (_toolCallId: string, input: { path: string; edits?: any[]; overwrite?: boolean; new_str?: string }, _signal: any, _onUpdate: any, ctx: any) => {
+      const cwd: string = ctx.cwd ?? process.cwd();
+
+      // Stale-read protection (only for edits, not overwrite)
+      if (!input.overwrite && input.path?.trim()) {
+        const absPath = resolveAbsolutePath(cwd, input.path);
+        const staleError = checkStaleFile(absPath, input.path);
+        if (staleError) throw new Error(staleError);
+      }
+
+      const result = await applyPatch(input as any, cwd);
+
+      // Update read markers after successful write
+      for (const filePath of [...result.modified, ...result.created]) {
+        const absPath = resolveAbsolutePath(cwd, filePath);
+        recordReadTime(absPath);
+      }
+
+      const summary = formatPatchResult(result);
+      const diff = generatePatchDiff(result);
+      return {
+        content: [{ type: "text", text: summary }],
+        details: { diff },
+      };
+    },
+
+    renderCall(args: any, theme: any, context: any) {
+      const state = context.state;
+      const component = getPatchCallComponent(state, context.lastComponent);
+
+      const argsKey = args ? JSON.stringify(args) : undefined;
+      if (component.previewArgsKey !== argsKey) {
+        component.preview = undefined;
+        component.previewArgsKey = argsKey;
+        component.previewPending = false;
+        component.settledError = false;
+      }
+
+      if (context.argsComplete && !component.preview && !component.previewPending) {
+        component.previewPending = true;
+        void computePatchPreview(args, context.cwd).then((preview: any) => {
+          component.preview = preview;
+          context.invalidate();
+        });
+      }
+
+      return buildPatchCallComponent(component, args, theme, context.expanded);
+    },
+
+    renderResult(result: any, options: any, theme: any, context: any) {
+      const callComponent: PatchCallComponent | undefined = context.state.callComponent;
+      let changed = false;
+
+      if (callComponent) {
+        if (callComponent.settledError !== context.isError) {
+          callComponent.settledError = context.isError;
+          changed = true;
+        }
+        if (changed) {
+          buildPatchCallComponent(callComponent, context.args, theme, options.expanded);
+          if (context.isError) {
+            const errorText = result.content
+              .filter((c: any) => c.type === "text")
+              .map((c: any) => c.text || "")
+              .join("\n");
+            if (errorText) {
+              callComponent.addChild(new Spacer(1));
+              callComponent.addChild(new Text(theme.fg("error", errorText), 0, 0));
+            }
+          }
+        }
+      }
+
+      const component = context.lastComponent ?? new Container();
+      component.clear();
+      return component;
+    },
+  }));
+}