decorated-pi 0.4.0 → 0.5.0

package/extensions/patch.ts

@@ -208,8 +208,8 @@ async function applyEdits(
       throw new ApplyError(`old_str must not be empty in ${displayPath}.`);
     }
 
-    const oldNorm = normalizeLineEndings(edit.old_str);
-    const newNorm = normalizeLineEndings(edit.new_str);
+    let oldNorm = normalizeLineEndings(edit.old_str);
+    let newNorm = normalizeLineEndings(edit.new_str);
 
     // Determine search range
     let searchFrom = 0;
@@ -227,46 +227,50 @@ async function applyEdits(
       } else {
         const secondAnchor = content.indexOf(anchorNorm, anchorIdx + 1);
         if (secondAnchor !== -1) {
-          throw new ApplyError(
-            `Anchor is not unique in ${displayPath}: "${truncate(edit.anchor)}" ` +
-            `found at multiple locations. Choose a more specific anchor.`
-          );
+          anchorNotFoundMessage = `Anchor is not unique in ${displayPath}: "${truncate(edit.anchor)}".`;
+        } else {
+          searchFrom = Math.max(0, anchorIdx - (oldNorm.length - 1));
+          displayAnchor = edit.anchor;
+          anchorMissing = false;
         }
-        // Search from anchor start position onward (anchor narrows search range)
-        // old_str may start at anchor position (anchor is a prefix of old_str)
-        searchFrom = anchorIdx;
-        displayAnchor = edit.anchor;
-        anchorMissing = false;
       }
     }
 
     // Find old_str in range — must be unique
     let matchIdx = anchorNotFoundMessage ? -1 : content.indexOf(oldNorm, searchFrom);
-    if (matchIdx === -1) {
-      if (anchorNotFoundMessage) {
-        displayAnchor = edit.anchor;
-        anchorMissing = true;
-        const globalMatchIdx = content.indexOf(oldNorm, 0);
-        if (globalMatchIdx === -1) {
-          throw new ApplyError(
-            `${anchorNotFoundMessage} old_str not found in ${displayPath}: "${truncate(edit.old_str)}". ` +
-            `The file may have changed — re-read it and try again.`
-          );
-        }
-        const secondGlobalMatch = content.indexOf(oldNorm, globalMatchIdx + 1);
+    if (matchIdx === -1 && anchorNotFoundMessage) {
+      // Anchor was missing/unusable — try global exact match first
+      displayAnchor = edit.anchor;
+      anchorMissing = true;
+      matchIdx = content.indexOf(oldNorm, 0);
+      if (matchIdx !== -1) {
+        const secondGlobalMatch = content.indexOf(oldNorm, matchIdx + 1);
         if (secondGlobalMatch !== -1) {
-          throw new ApplyError(
-            `${anchorNotFoundMessage} old_str is not unique in ${displayPath}: "${truncate(edit.old_str)}". ` +
-            `Add more context to old_str or use a more specific anchor.`
-          );
+          const dupDiag = diagnoseOldStrNotUnique(oldNorm, content);
+          throw new ApplyError(`${anchorNotFoundMessage}\n${dupDiag}`);
         }
-        matchIdx = globalMatchIdx;
+      }
+    }
+
+    if (matchIdx === -1) {
+      // Fuzzy match fallback: normalize tab↔space + trailing whitespace
+      const searchLine = searchFrom === 0 ? 0 : content.substring(0, searchFrom).split("\n").length - 1;
+      const fuzzy = tryFuzzyLineMatch(oldNorm, content, searchLine);
+      if (fuzzy) {
+        oldNorm = fuzzy.matched;
+        matchIdx = fuzzy.idx;
+        newNorm = normalizeIndentForFuzzy(fuzzy.matched.split("\n")[0] ?? "", newNorm);
+      } else if (anchorNotFoundMessage) {
+        const diag = diagnoseOldStrMismatch(oldNorm, content);
+        throw new ApplyError(
+          `${anchorNotFoundMessage}\nold_str not found in ${displayPath}: "${truncate(edit.old_str)}".\n${diag}`
+        );
       } else {
+        const diag = diagnoseOldStrMismatch(oldNorm, content);
         throw new ApplyError(
           `old_str not found in ${displayPath}` +
           (edit.anchor ? ` after anchor "${truncate(edit.anchor)}"` : "") +
-          `: "${truncate(edit.old_str)}". ` +
-          `The file may have changed — re-read it and try again.`
+          `: "${truncate(edit.old_str)}".\n${diag}`
         );
       }
     }
@@ -275,9 +279,9 @@ async function applyEdits(
     if (!anchorNotFoundMessage) {
       const secondMatch = content.indexOf(oldNorm, matchIdx + 1);
       if (secondMatch !== -1) {
+        const dupDiag = diagnoseOldStrNotUnique(oldNorm, content);
         throw new ApplyError(
-          `old_str is not unique in ${displayPath}: "${truncate(edit.old_str)}". ` +
-          `Add more context to old_str or use an anchor to narrow the search.`
+          `${dupDiag}`
         );
       }
     }
@@ -322,9 +326,10 @@ async function applyEdits(
 
   // Generate diff using only needed context lines (no full-file split)
   const mergedRanges = mergeRanges(neededRanges);
+  const currentLineOffsets = buildLineOffsets(content);
   const neededLines: Map<number, string> = new Map();
   for (const range of mergedRanges) {
-    const lines = extractLineRange(content, lineOffsets, range.startLine, range.endLine);
+    const lines = extractLineRange(content, currentLineOffsets, range.startLine, range.endLine);
     for (let i = 0; i < lines.length; i++) {
       neededLines.set(range.startLine + i, lines[i]);
     }
@@ -395,8 +400,8 @@ export async function computePatchPreview(
 
       for (const edit of patch.edits) {
         if (!edit.old_str) continue;
-        const oldNorm = normalizeLineEndings(edit.old_str);
-        const newNorm = normalizeLineEndings(edit.new_str);
+        let oldNorm = normalizeLineEndings(edit.old_str);
+        let newNorm = normalizeLineEndings(edit.new_str);
 
         let searchFrom = 0;
         let displayAnchor: string | undefined;
@@ -410,30 +415,42 @@ export async function computePatchPreview(
           } else {
             const secondAnchor = content.indexOf(anchorNorm, idx + 1);
             if (secondAnchor !== -1) {
-              return { error: `Anchor is not unique: "${truncate(edit.anchor)}"` };
+              anchorNotFoundMessage = `Anchor is not unique: "${truncate(edit.anchor)}"`;
+            } else {
+              searchFrom = Math.max(0, idx - (oldNorm.length - 1));
+              displayAnchor = edit.anchor;
+              anchorMissing = false;
             }
-            searchFrom = idx;
-            displayAnchor = edit.anchor;
-            anchorMissing = false;
           }
         }
 
         let matchIdx = anchorNotFoundMessage ? -1 : content.indexOf(oldNorm, searchFrom);
-        if (matchIdx === -1) {
-          if (anchorNotFoundMessage) {
-            displayAnchor = edit.anchor;
-            anchorMissing = true;
-            const globalMatchIdx = content.indexOf(oldNorm, 0);
-            if (globalMatchIdx === -1) {
-              return { error: `${anchorNotFoundMessage}; old_str not found: "${truncate(edit.old_str)}"` };
-            }
-            const secondGlobalMatch = content.indexOf(oldNorm, globalMatchIdx + 1);
+        if (matchIdx === -1 && anchorNotFoundMessage) {
+          displayAnchor = edit.anchor;
+          anchorMissing = true;
+          matchIdx = content.indexOf(oldNorm, 0);
+          if (matchIdx !== -1) {
+            const secondGlobalMatch = content.indexOf(oldNorm, matchIdx + 1);
             if (secondGlobalMatch !== -1) {
-              return { error: `${anchorNotFoundMessage}; old_str is not unique: "${truncate(edit.old_str)}"` };
+              const dupDiag = diagnoseOldStrNotUnique(oldNorm, content);
+              return { error: `${anchorNotFoundMessage}\n${dupDiag}` };
             }
-            matchIdx = globalMatchIdx;
+          }
+        }
+
+        if (matchIdx === -1) {
+          const searchLine = 0;
+          const fuzzy = tryFuzzyLineMatch(oldNorm, content, searchLine);
+          if (fuzzy) {
+            oldNorm = fuzzy.matched;
+            matchIdx = fuzzy.idx;
+            newNorm = normalizeIndentForFuzzy(fuzzy.matched.split("\n")[0] ?? "", newNorm);
+          } else if (anchorNotFoundMessage) {
+            const diag = diagnoseOldStrMismatch(oldNorm, content);
+            return { error: `${anchorNotFoundMessage}\nold_str not found: "${truncate(edit.old_str)}"\n${diag}` };
           } else {
-            return { error: `old_str not found: "${truncate(edit.old_str)}"` };
+            const diag = diagnoseOldStrMismatch(oldNorm, content);
+            return { error: `old_str not found: "${truncate(edit.old_str)}".\n${diag}` };
           }
         }
 
@@ -456,9 +473,10 @@ export async function computePatchPreview(
 
       // Merge needed ranges and extract only those lines
       const mergedRanges = mergeRanges(neededRanges);
+      const currentLineOffsets = buildLineOffsets(content);
       const neededLines: Map<number, string> = new Map();
       for (const range of mergedRanges) {
-        const lines = extractLineRange(content, lineOffsets, range.startLine, range.endLine);
+        const lines = extractLineRange(content, currentLineOffsets, range.startLine, range.endLine);
         for (let i = 0; i < lines.length; i++) {
           neededLines.set(range.startLine + i, lines[i]);
         }
@@ -833,6 +851,168 @@ function generateLocalDiff(
   return parts.join("\n");
 }
 
+// ─── old_str mismatch diagnostics ─────────────────────────────────────────
+
+/** Detect tab width from the file by analyzing indentation columns of tab-only lines. */
+function detectTabWidth(content: string): number {
+  const lines = content.split("\n");
+  const cols: number[] = [];
+  for (const line of lines) {
+    const nonTabIdx = line.search(/[^\t]/);
+    if (nonTabIdx === -1 || nonTabIdx === 0) continue;
+    cols.push(nonTabIdx);
+  }
+  if (cols.length < 2) return 0;
+  const diffs: number[] = [];
+  for (let i = 1; i < cols.length; i++) {
+    if (cols[i] === cols[i - 1] || cols[i]! > cols[i - 1]! + 8) continue;
+    diffs.push(cols[i]! - cols[i - 1]!);
+  }
+  if (diffs.length === 0) return 0;
+  const sorted = [...diffs].sort((a, b) => a - b);
+  const median = sorted[Math.floor(sorted.length / 2)]!;
+  return [2, 4, 8].reduce((best, w) => Math.abs(w - median) < Math.abs(best - median) ? w : best, 4);
+}
+
+export function diagnoseOldStrNotUnique(oldNorm: string, content: string): string {
+  const fileLines = content.split("\n");
+  const firstOldLine = (oldNorm.split("\n")[0] ?? "").trim();
+  const occurrences: number[] = [];
+  let idx = 0;
+  while ((idx = content.indexOf(oldNorm, idx)) !== -1) {
+    const lineNum = content.substring(0, idx).split("\n").length;
+    occurrences.push(lineNum);
+    idx++;
+  }
+  if (occurrences.length === 0) return "";
+  const shown = occurrences.slice(0, 5);
+  const extra = occurrences.length - shown.length;
+  const lines = shown.map((n) => `  line ${n}: "${(fileLines[n - 1] ?? "").replace(/\t/g, "\\t").slice(0, 60)}"`);
+  if (extra > 0) lines.push(`  and ${extra} more occurrence(s)`);
+  return `old_str appears ${occurrences.length} times:\n${lines.join("\n")}\nAdd more surrounding context to make it unique.`;
+}
+
+/** Try fuzzy match: normalize tab↔space and trailing whitespace, then search line-by-line. */
+function tryFuzzyLineMatch(
+  oldNorm: string,
+  content: string,
+  searchLineStart: number,
+): { idx: number; matched: string } | undefined {
+  const oldLines = oldNorm.split("\n");
+  const fileLines = content.split("\n");
+
+  const fuzzyEq = (fileLine: string, oldLine: string): boolean => {
+    if (fileLine === oldLine) return true;
+    for (const tw of [8, 4, 2]) {
+      if (fileLine.replace(/\t/g, " ".repeat(tw)) === oldLine.replace(/\t/g, " ".repeat(tw))) return true;
+    }
+    if (fileLine.replace(/[\t ]+$/, "") === oldLine.replace(/[\t ]+$/, "")) return true;
+    return false;
+  };
+
+  for (let i = searchLineStart; i <= fileLines.length - oldLines.length; i++) {
+    let ok = true;
+    for (let j = 0; j < oldLines.length; j++) {
+      if (!fuzzyEq(fileLines[i + j] ?? "", oldLines[j] ?? "")) { ok = false; break; }
+    }
+    if (ok) {
+      let idx = 0;
+      for (let k = 0; k < i; k++) idx += (fileLines[k] ?? "").length + 1;
+      const matched = oldLines.map((_, j) => fileLines[i + j]).join("\n");
+      // Check uniqueness in the fuzzy-matched range
+      const secondIdx = content.indexOf(matched, idx + 1);
+      if (secondIdx === -1) return { idx, matched };
+    }
+  }
+  return undefined;
+}
+
+/** Replace new_str's leading whitespace with the actual file line's leading whitespace style. */
+function normalizeIndentForFuzzy(actualLine: string, newLine: string): string {
+  const actualLeading = actualLine.match(/^[\t ]*/)?.[0] ?? "";
+  const newLeading = newLine.match(/^[\t ]*/)?.[0] ?? "";
+  if (actualLeading === newLeading) return newLine;
+  return actualLeading + newLine.slice(newLeading.length);
+}
+
+export function diagnoseOldStrMismatch(oldNorm: string, content: string, isConfigFile?: boolean): string {
+  const oldLines = oldNorm.split("\n");
+  const fileLines = content.split("\n");
+  const firstOldLine = oldLines[0] ?? "";
+  const parts: string[] = [];
+
+  // Find the closest matching line in the file
+  let bestMatchIdx = -1;
+  let bestMatchType = "";
+
+  for (let i = 0; i < fileLines.length; i++) {
+    const fileLine = fileLines[i] ?? "";
+
+    if (fileLine === firstOldLine) {
+      bestMatchIdx = i;
+      bestMatchType = "";
+      break;
+    }
+
+    if (fileLine.replace(/\t/g, "        ") === firstOldLine ||
+        fileLine.replace(/\t/g, "    ") === firstOldLine ||
+        fileLine.replace(/\t/g, "  ") === firstOldLine) {
+      bestMatchIdx = i;
+      bestMatchType = "tab vs space (file has tabs, old_str has spaces)";
+      break;
+    }
+
+    if (fileLine.replace(/[\t ]+$/, "") === firstOldLine.replace(/[\t ]+$/, "")) {
+      bestMatchIdx = i;
+      bestMatchType = "trailing whitespace mismatch";
+      break;
+    }
+
+    if (fileLine.toLowerCase() === firstOldLine.toLowerCase()) {
+      bestMatchIdx = i;
+      bestMatchType = "case mismatch";
+      break;
+    }
+
+    const trimmedOld = firstOldLine.trim();
+    if (trimmedOld.length > 3 && fileLine.includes(trimmedOld)) {
+      if (bestMatchIdx === -1) {
+        bestMatchIdx = i;
+        bestMatchType = "indent mismatch (content matches, whitespace differs)";
+      }
+    }
+  }
+
+  if (bestMatchIdx >= 0 && bestMatchType) {
+    parts.push(`Hint: ${bestMatchType} at line ${bestMatchIdx + 1}.`);
+    parts.push(`  actual: ${JSON.stringify(fileLines[bestMatchIdx])}`);
+    parts.push(`  expected: ${JSON.stringify(firstOldLine)}`);
+  } else if (bestMatchIdx >= 0) {
+    // First line matched, but full old_str block does not — find the first mismatching line
+    const oldArr = oldNorm.split("\n");
+    let mismatchLine = 0;
+    for (let j = 1; j < oldArr.length; j++) {
+      const fileLine = fileLines[bestMatchIdx + j] ?? "<EOF>";
+      const oldLine = oldArr[j] ?? "";
+      if (fileLine !== oldLine) {
+        mismatchLine = bestMatchIdx + j + 1;
+        parts.push(`Line ${bestMatchIdx + 1} matches, but diff at line ${mismatchLine}:`);
+        parts.push(`  actual: ${JSON.stringify(fileLine)}`);
+        parts.push(`  expected: ${JSON.stringify(oldLine)}`);
+        break;
+      }
+    }
+    if (mismatchLine === 0) {
+      parts.push(`First line matches at line ${bestMatchIdx + 1}, but full ${oldArr.length}-line block does not.`);
+    }
+  } else if (firstOldLine.trim().length > 3) {
+    parts.push(`Content "${firstOldLine.trim().slice(0, 60)}" not found anywhere in the file.`);
+    parts.push(`File may have changed — re-read it and try again.`);
+  }
+
+  return parts.join("\n");
+}
+
 function truncate(s: string, maxLen = 60): string {
   if (s.length <= maxLen) return s;
   // Show first line only

package/extensions/rtk.ts

@@ -0,0 +1,244 @@
+/**
+ * RTK integration — Rewrite bash commands through system-installed RTK
+ *
+ * Uses `rtk rewrite` as a preflight step. If RTK is not installed on PATH,
+ * this module stays inactive. When a rewritten RTK command fails, the original
+ * command is executed once as a fallback.
+ */
+
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { createBashToolDefinition, createLocalBashOperations, isToolCallEventType } from "@earendil-works/pi-coding-agent";
+import { Text } from "@earendil-works/pi-tui";
+import { execFileSync, spawnSync } from "node:child_process";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+
+let rtkBinary: string | null = null;
+
+interface PiShellSettings {
+  shellPath?: string;
+  shellCommandPrefix?: string;
+}
+
+export interface DependencyStatus {
+  module: string;
+  label: string;
+  state: "ok" | "missing" | "n/a";
+  detail?: string;
+}
+
+function readJsonObject(filePath: string): Record<string, unknown> {
+  try {
+    if (!fs.existsSync(filePath)) return {};
+    const parsed = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+    return parsed && typeof parsed === "object" ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+
+function loadPiShellSettings(cwd: string): PiShellSettings {
+  const agentDir = process.env.PI_CODING_AGENT_DIR || path.join(os.homedir(), ".pi", "agent");
+  const globalSettings = readJsonObject(path.join(agentDir, "settings.json"));
+  const projectSettings = readJsonObject(path.join(cwd, ".pi", "settings.json"));
+  const merged = { ...globalSettings, ...projectSettings } as Record<string, unknown>;
+  const result: PiShellSettings = {};
+  if (typeof merged.shellPath === "string" && merged.shellPath.trim()) result.shellPath = merged.shellPath;
+  if (typeof merged.shellCommandPrefix === "string" && merged.shellCommandPrefix.trim()) {
+    result.shellCommandPrefix = merged.shellCommandPrefix;
+  }
+  return result;
+}
+
+export function findSystemRtk(): string | null {
+  try {
+    if (process.platform === "win32") {
+      const output = execFileSync("where", ["rtk"], { encoding: "utf-8" }).trim();
+      return output.split(/\r?\n/)[0] || null;
+    }
+    const shell = process.env.SHELL || "sh";
+    return execFileSync(shell, ["-lc", "command -v rtk"], { encoding: "utf-8" }).trim() || null;
+  } catch {
+    return null;
+  }
+}
+
+export function shellQuote(value: string): string {
+  return `'${value.replace(/'/g, `'"'"'`)}'`;
+}
+
+export function buildRtkCommand(raw: string, rtkBinaryPath: string): string {
+  const binDir = path.dirname(rtkBinaryPath);
+  return `export PATH=${shellQuote(binDir)}:$PATH && ${raw}`;
+}
+
+export function extractMainCommand(command: string): string {
+  let cmd = command.trim().toLowerCase();
+  cmd = cmd.replace(/^cd\s+\S+\s*(&&|;|\n)\s*/, "");
+  cmd = cmd.replace(/^(?:[a-z_][a-z0-9_]*=\S*\s+)+/, "");
+  const prefixes = ["sudo ", "time ", "nohup ", "nice ", "env "];
+  let changed = true;
+  while (changed) {
+    changed = false;
+    for (const prefix of prefixes) {
+      if (cmd.startsWith(prefix)) {
+        cmd = cmd.slice(prefix.length);
+        changed = true;
+      }
+    }
+  }
+  return cmd;
+}
+
+export function shouldBypassRtkRewrite(command: string): boolean {
+  const main = extractMainCommand(command);
+  if (!main.startsWith("find ") && main !== "find") return false;
+  return /(^|\s)(-o|-or|-a|-and|-not|!|\(|\)|-exec|-ok|-delete|-prune|-printf|-print0)(\s|$)/.test(main);
+}
+
+export function rewriteWithRtk(command: string, rtkPath: string): string | null {
+  if (shouldBypassRtkRewrite(command)) return null;
+
+  // NOTE:
+  // Some RTK versions return a non-zero exit code even when `rtk rewrite`
+  // successfully prints a rewritten command to stdout (observed locally with
+  // RTK 0.42.0 returning exit code 3 on success). Because of that, we treat
+  // non-empty stdout as the source of truth and ignore the process exit code
+  // here. Empty stdout still means “no rewrite available”.
+  const result = spawnSync(rtkPath, ["rewrite", command], {
+    encoding: "utf-8",
+    timeout: 2000,
+  });
+  const raw = (result.stdout ?? "").trim();
+  if (!raw) return null;
+  return buildRtkCommand(raw, rtkPath);
+}
+
+export function appendStatus(text: string, status: string): string {
+  return text ? `${text}\n\n${status}` : status;
+}
+
+function formatBashCallWithTag(args: { command?: unknown; timeout?: unknown }, theme: any, showTag: boolean): string {
+  const command = typeof args?.command === "string" ? args.command : null;
+  const timeout = typeof args?.timeout === "number" ? args.timeout : undefined;
+  const timeoutSuffix = timeout ? theme.fg("muted", ` (timeout ${timeout}s)`) : "";
+  const commandDisplay = command === null ? theme.fg("error", "<invalid command>") : command || theme.fg("toolOutput", "...");
+  const tag = showTag ? theme.fg("borderAccent", " [RTK]") : "";
+  return theme.fg("toolTitle", theme.bold(`$ ${commandDisplay}`)) + timeoutSuffix + tag;
+}
+
+export async function executeOriginalBash(command: string, cwd: string, timeout: number | undefined, signal?: AbortSignal) {
+  const ops = createLocalBashOperations();
+  const chunks: Buffer[] = [];
+  const onData = (data: Buffer) => chunks.push(Buffer.from(data));
+  const getOutput = () => Buffer.concat(chunks).toString("utf-8");
+
+  try {
+    const result = await ops.exec(command, cwd, { onData, signal, timeout });
+    const output = getOutput() || "(no output)";
+    if (result.exitCode !== 0 && result.exitCode !== null) {
+      return {
+        content: [{ type: "text" as const, text: appendStatus(output, `Command exited with code ${result.exitCode}`) }],
+        details: undefined,
+        isError: true,
+      };
+    }
+    return {
+      content: [{ type: "text" as const, text: output }],
+      details: undefined,
+      isError: false,
+    };
+  } catch (err) {
+    const output = getOutput();
+    if (err instanceof Error && err.message === "aborted") {
+      return {
+        content: [{ type: "text" as const, text: appendStatus(output, "Command aborted") }],
+        details: undefined,
+        isError: true,
+      };
+    }
+    if (err instanceof Error && err.message.startsWith("timeout:")) {
+      const timeoutSecs = err.message.split(":")[1];
+      return {
+        content: [{ type: "text" as const, text: appendStatus(output, `Command timed out after ${timeoutSecs} seconds`) }],
+        details: undefined,
+        isError: true,
+      };
+    }
+    return {
+      content: [{ type: "text" as const, text: appendStatus(output, err instanceof Error ? err.message : "Command failed") }],
+      details: undefined,
+      isError: true,
+    };
+  }
+}
+
+export function getRtkDependencyStatuses(): DependencyStatus[] {
+  return [{
+    module: "rtk",
+    label: "rtk",
+    state: findSystemRtk() ? "ok" : "missing",
+    detail: "Install RTK so bash rewrite/tagging can activate.",
+  }];
+}
+
+export function setupRtkIntegration(pi: ExtensionAPI) {
+  rtkBinary = findSystemRtk();
+  if (!rtkBinary) return;
+
+  const rewrittenCommands = new Map<string, { originalCommand: string; timeout?: number }>();
+  const rewriteabilityCache = new Map<string, boolean>();
+  const shellSettings = loadPiShellSettings(process.cwd());
+  const bashTool = createBashToolDefinition(process.cwd(), {
+    shellPath: shellSettings.shellPath,
+    commandPrefix: shellSettings.shellCommandPrefix,
+  });
+  const baseRenderCall = bashTool.renderCall?.bind(bashTool);
+
+  if (baseRenderCall) {
+    bashTool.renderCall = (args, theme, context) => {
+      const component = baseRenderCall(args, theme, context);
+      const command = typeof args?.command === "string" ? args.command : "";
+      const predicted = command
+        ? (rewriteabilityCache.get(command) ?? (() => {
+            const value = rewriteWithRtk(command, rtkBinary!) !== null;
+            rewriteabilityCache.set(command, value);
+            return value;
+          })())
+        : false;
+      const rewritten = rewrittenCommands.has(context.toolCallId) || predicted;
+      if (component instanceof Text) {
+        component.setText(formatBashCallWithTag(args as any, theme, rewritten));
+      }
+      return component;
+    };
+  }
+
+  pi.registerTool(bashTool);
+
+  pi.on("tool_call", (event) => {
+    if (!isToolCallEventType("bash", event)) return;
+    const command = event.input.command;
+    if (!command.trim()) return;
+    const rewritten = rewriteWithRtk(command, rtkBinary!);
+    rewriteabilityCache.set(command, rewritten !== null);
+    if (!rewritten) return;
+    rewrittenCommands.set(event.toolCallId, { originalCommand: command, timeout: event.input.timeout });
+    event.input.command = rewritten;
+  });
+
+  pi.on("tool_result", async (event, ctx) => {
+    if (event.toolName !== "bash") return;
+    const pending = rewrittenCommands.get(event.toolCallId);
+    if (!pending) return;
+    rewrittenCommands.delete(event.toolCallId);
+    if (!event.isError) return;
+    return executeOriginalBash(pending.originalCommand, ctx.cwd, pending.timeout, ctx.signal);
+  });
+
+  pi.on("session_shutdown", () => {
+    rewrittenCommands.clear();
+    rewriteabilityCache.clear();
+  });
+}