@cortexkit/aft-pi 0.14.0 → 0.14.1

package/dist/index.js

@@ -3,7 +3,7 @@ var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 // src/index.ts
 import { createRequire as createRequire3 } from "node:module";
-import { homedir as homedir5 } from "node:os";
+import { homedir as homedir6 } from "node:os";
 import { join as join8 } from "node:path";
 
 // src/shared/status.ts
@@ -1471,8 +1471,117 @@ function registerFsTools(pi, ctx, surface) {
 
 // src/tools/hoisted.ts
 import { stat } from "node:fs/promises";
+import { homedir as homedir5 } from "node:os";
 import { resolve } from "node:path";
+import {
+  renderDiff
+} from "@mariozechner/pi-coding-agent";
+import { Container, Spacer, Text } from "@mariozechner/pi-tui";
 import { Type as Type4 } from "@sinclair/typebox";
+
+// src/tools/diff-format.ts
+import { diffLines } from "diff";
+var DEFAULT_CONTEXT_LINES = 4;
+function formatDiffForPi(oldContent, newContent, contextLines = DEFAULT_CONTEXT_LINES) {
+  const parts = diffLines(oldContent, newContent);
+  const output = [];
+  const oldLines = oldContent.split(`
+`);
+  const newLines = newContent.split(`
+`);
+  const maxLineNum = Math.max(oldLines.length, newLines.length);
+  const lineNumWidth = String(maxLineNum).length;
+  const pad = (n) => String(n).padStart(lineNumWidth, " ");
+  const blank = " ".repeat(lineNumWidth);
+  let oldLineNum = 1;
+  let newLineNum = 1;
+  let lastWasChange = false;
+  let firstChangedLine;
+  for (let i = 0;i < parts.length; i++) {
+    const part = parts[i];
+    const raw = part.value.split(`
+`);
+    if (raw[raw.length - 1] === "")
+      raw.pop();
+    if (part.added || part.removed) {
+      if (firstChangedLine === undefined)
+        firstChangedLine = newLineNum;
+      for (const line of raw) {
+        if (part.added) {
+          output.push(`+${pad(newLineNum)} ${line}`);
+          newLineNum++;
+        } else {
+          output.push(`-${pad(oldLineNum)} ${line}`);
+          oldLineNum++;
+        }
+      }
+      lastWasChange = true;
+      continue;
+    }
+    const nextIsChange = i < parts.length - 1 && (parts[i + 1].added || parts[i + 1].removed);
+    const hasLeading = lastWasChange;
+    const hasTrailing = nextIsChange;
+    if (hasLeading && hasTrailing) {
+      if (raw.length <= contextLines * 2) {
+        for (const line of raw) {
+          output.push(` ${pad(oldLineNum)} ${line}`);
+          oldLineNum++;
+          newLineNum++;
+        }
+      } else {
+        for (const line of raw.slice(0, contextLines)) {
+          output.push(` ${pad(oldLineNum)} ${line}`);
+          oldLineNum++;
+          newLineNum++;
+        }
+        const skipped = raw.length - contextLines * 2;
+        output.push(` ${blank} ...`);
+        oldLineNum += skipped;
+        newLineNum += skipped;
+        for (const line of raw.slice(raw.length - contextLines)) {
+          output.push(` ${pad(oldLineNum)} ${line}`);
+          oldLineNum++;
+          newLineNum++;
+        }
+      }
+    } else if (hasLeading) {
+      const shown = raw.slice(0, contextLines);
+      for (const line of shown) {
+        output.push(` ${pad(oldLineNum)} ${line}`);
+        oldLineNum++;
+        newLineNum++;
+      }
+      const skipped = raw.length - shown.length;
+      if (skipped > 0) {
+        output.push(` ${blank} ...`);
+        oldLineNum += skipped;
+        newLineNum += skipped;
+      }
+    } else if (hasTrailing) {
+      const shownCount = Math.min(contextLines, raw.length);
+      const shown = raw.slice(raw.length - shownCount);
+      const skipped = raw.length - shown.length;
+      if (skipped > 0) {
+        output.push(` ${blank} ...`);
+        oldLineNum += skipped;
+        newLineNum += skipped;
+      }
+      for (const line of shown) {
+        output.push(` ${pad(oldLineNum)} ${line}`);
+        oldLineNum++;
+        newLineNum++;
+      }
+    } else {
+      oldLineNum += raw.length;
+      newLineNum += raw.length;
+    }
+    lastWasChange = false;
+  }
+  return { diff: output.join(`
+`), firstChangedLine };
+}
+
+// src/tools/hoisted.ts
 var ReadParams = Type4.Object({
   path: Type4.String({ description: "Path to the file to read (relative or absolute)" }),
   offset: Type4.Optional(Type4.Number({ description: "Line number to start reading from (1-indexed)" })),
@@ -1504,6 +1613,8 @@ function registerHoistedTools(pi, ctx, surface) {
       name: "read",
       label: "read",
       description: "Read file contents with line numbers. Backed by AFT's indexed Rust reader — faster than the built-in `read` on large repos and correctly handles images/PDFs as attachments.",
+      promptSnippet: "Read file contents (supports offset/limit for large files)",
+      promptGuidelines: ["Use read to examine files instead of cat or sed."],
       parameters: ReadParams,
       async execute(_toolCallId, params, _signal, _onUpdate, extCtx) {
         const bridge = bridgeFor(ctx, extCtx.cwd);
@@ -1530,30 +1641,24 @@ function registerHoistedTools(pi, ctx, surface) {
     pi.registerTool({
       name: "write",
       label: "write",
-      description: "Write a file atomically with per-file backup, optional auto-format, and inline LSP diagnostics. Parent directories are created automatically. Overwrites existing files.",
+      description: "Write a file atomically with per-file backup, optional auto-format, and inline LSP diagnostics. Parent directories are created automatically. Overwrites existing files. Uses `filePath` (not `path`).",
+      promptSnippet: "Create or overwrite files (uses filePath; auto-formats; returns LSP diagnostics inline)",
+      promptGuidelines: ["Use write only for new files or complete rewrites."],
       parameters: WriteParams,
       async execute(_toolCallId, params, _signal, _onUpdate, extCtx) {
         const bridge = bridgeFor(ctx, extCtx.cwd);
         const response = await callBridge(bridge, "write", {
           file: params.filePath,
-          content: params.content
-        });
-        const diffAdd = response.diff?.additions ?? 0;
-        const diffDel = response.diff?.deletions ?? 0;
-        const diagnostics = response.lsp_diagnostics;
-        let summary = `Wrote ${params.filePath} (+${diffAdd}/-${diffDel})`;
-        if (diagnostics && diagnostics.length > 0) {
-          summary += `
-
-LSP diagnostics:
-${JSON.stringify(diagnostics, null, 2)}`;
-        }
-        return textResult(summary, {
-          filePath: params.filePath,
-          additions: diffAdd,
-          deletions: diffDel,
-          diagnostics
+          content: params.content,
+          include_diff: true
         });
+        return buildMutationResult(params.filePath, response);
+      },
+      renderCall(args, theme, context) {
+        return renderMutationCall("write", args?.filePath, theme, context);
+      },
+      renderResult(result, _options, theme, context) {
+        return renderMutationResult(result, theme, context);
       }
     });
   }
@@ -1561,39 +1666,33 @@ ${JSON.stringify(diagnostics, null, 2)}`;
     pi.registerTool({
       name: "edit",
       label: "edit",
-      description: "Find-and-replace edit with progressive fuzzy matching (handles whitespace and Unicode drift). Returns an error if multiple matches are found — use `occurrence` to select one, or `replaceAll: true` to replace all. Always returns inline LSP diagnostics for the edited file.",
+      description: "Find-and-replace edit with progressive fuzzy matching (handles whitespace and Unicode drift). Uses `filePath`, `oldString`, `newString`. Errors on multiple matches — use `occurrence` to pick one, or `replaceAll: true`. Always returns LSP diagnostics inline.",
+      promptSnippet: "Targeted find-and-replace (uses filePath/oldString/newString; occurrence or replaceAll for disambiguation; fuzzy whitespace matching)",
+      promptGuidelines: [
+        "Prefer edit over write when changing part of an existing file.",
+        "Include enough surrounding context in oldString to make the match unique, or set replaceAll/occurrence explicitly."
+      ],
       parameters: EditParams,
       async execute(_toolCallId, params, _signal, _onUpdate, extCtx) {
         const bridge = bridgeFor(ctx, extCtx.cwd);
         const req = {
           file: params.filePath,
           match: params.oldString ?? "",
-          replacement: params.newString ?? ""
+          replacement: params.newString ?? "",
+          include_diff: true
         };
         if (params.replaceAll === true)
           req.replace_all = true;
         if (params.occurrence !== undefined)
           req.occurrence = params.occurrence;
         const response = await callBridge(bridge, "edit_match", req);
-        const diff = response.diff;
-        const diffAdd = diff?.additions ?? 0;
-        const diffDel = diff?.deletions ?? 0;
-        const replacements = response.replacements;
-        const diagnostics = response.lsp_diagnostics;
-        let summary = `Edited ${params.filePath} (+${diffAdd}/-${diffDel}, ${replacements ?? 1} replacement${replacements === 1 ? "" : "s"})`;
-        if (diagnostics && diagnostics.length > 0) {
-          summary += `
-
-LSP diagnostics:
-${JSON.stringify(diagnostics, null, 2)}`;
-        }
-        return textResult(summary, {
-          filePath: params.filePath,
-          additions: diffAdd,
-          deletions: diffDel,
-          replacements,
-          diagnostics
-        });
+        return buildMutationResult(params.filePath, response);
+      },
+      renderCall(args, theme, context) {
+        return renderMutationCall("edit", args?.filePath, theme, context);
+      },
+      renderResult(result, _options, theme, context) {
+        return renderMutationResult(result, theme, context);
       }
     });
   }
@@ -1602,6 +1701,8 @@ ${JSON.stringify(diagnostics, null, 2)}`;
       name: "grep",
       label: "grep",
       description: "Search for a regex pattern across files. Uses AFT's trigram index inside the project root for fast repeated queries, and falls back to ripgrep for paths outside the project root.",
+      promptSnippet: "Fast regex search across files (trigram-indexed inside the project root)",
+      promptGuidelines: ["Prefer grep over bash-invoked find/rg for in-project searches."],
       parameters: GrepParams,
       async execute(_toolCallId, params, _signal, _onUpdate, extCtx) {
         const bridge = bridgeFor(ctx, extCtx.cwd);
@@ -1621,6 +1722,112 @@ ${JSON.stringify(diagnostics, null, 2)}`;
     });
   }
 }
+function buildMutationResult(filePath, response) {
+  const diffObj = response.diff;
+  const additions = diffObj?.additions ?? 0;
+  const deletions = diffObj?.deletions ?? 0;
+  const replacements = response.replacements;
+  const diagnostics = response.lsp_diagnostics;
+  const truncated = diffObj?.truncated === true;
+  let diffText;
+  let firstChangedLine;
+  if (diffObj && !truncated && typeof diffObj.before === "string" && typeof diffObj.after === "string") {
+    const formatted = formatDiffForPi(diffObj.before, diffObj.after);
+    diffText = formatted.diff;
+    firstChangedLine = formatted.firstChangedLine;
+  }
+  const summaryHeader = replacements !== undefined ? `Edited ${filePath} (+${additions}/-${deletions}, ${replacements} replacement${replacements === 1 ? "" : "s"})` : `Wrote ${filePath} (+${additions}/-${deletions})`;
+  let text = summaryHeader;
+  if (diffText)
+    text += `
+
+${diffText}`;
+  if (truncated) {
+    text += `
+
+(diff truncated — file too large to include before/after content)`;
+  }
+  if (diagnostics && diagnostics.length > 0) {
+    text += `
+
+LSP diagnostics:
+${formatDiagnosticsText(diagnostics)}`;
+  }
+  return {
+    content: [{ type: "text", text }],
+    details: {
+      diff: diffText,
+      firstChangedLine,
+      additions,
+      deletions,
+      replacements,
+      diagnostics,
+      truncated: truncated || undefined
+    }
+  };
+}
+function formatDiagnosticsText(diagnostics) {
+  try {
+    return diagnostics.map((d) => {
+      if (d && typeof d === "object") {
+        const obj = d;
+        const line = obj.line ?? obj.startLine ?? "?";
+        const severity = obj.severity ?? "info";
+        const msg = obj.message ?? JSON.stringify(obj);
+        return `  [${severity}] line ${line}: ${msg}`;
+      }
+      return `  ${String(d)}`;
+    }).join(`
+`);
+  } catch {
+    return JSON.stringify(diagnostics, null, 2);
+  }
+}
+function reuseText(last) {
+  return last instanceof Text ? last : new Text("", 0, 0);
+}
+function reuseContainer(last) {
+  return last instanceof Container ? last : new Container;
+}
+function renderMutationCall(toolName, filePath, theme, context) {
+  const text = reuseText(context.lastComponent);
+  const pathDisplay = filePath ? theme.fg("accent", shortenPath(filePath)) : theme.fg("toolOutput", "...");
+  text.setText(`${theme.fg("toolTitle", theme.bold(toolName))} ${pathDisplay}`);
+  return text;
+}
+function renderMutationResult(result, theme, context) {
+  if (context.isError) {
+    const errorText = result.content.filter((c) => c.type === "text").map((c) => c.text ?? "").join(`
+`).trim();
+    const text = reuseText(context.lastComponent);
+    text.setText(`
+${theme.fg("error", errorText || "edit failed")}`);
+    return text;
+  }
+  const details = result.details;
+  const diff = typeof details?.diff === "string" ? details.diff : undefined;
+  if (!diff) {
+    const additions = details?.additions ?? 0;
+    const deletions = details?.deletions ?? 0;
+    const text = reuseText(context.lastComponent);
+    const summary = theme.fg("success", `+${additions}/-${deletions}`);
+    const suffix = details?.truncated ? ` ${theme.fg("muted", "(diff truncated)")}` : "";
+    text.setText(`
+${summary}${suffix}`);
+    return text;
+  }
+  const container = reuseContainer(context.lastComponent);
+  container.clear();
+  container.addChild(new Spacer(1));
+  container.addChild(new Text(renderDiff(diff), 1, 0));
+  return container;
+}
+function shortenPath(path2) {
+  const home = homedir5();
+  if (path2.startsWith(home))
+    return `~${path2.slice(home.length)}`;
+  return path2;
+}
 async function resolvePathArg(cwd, path2) {
   const abs = resolve(cwd, path2);
   try {
@@ -2038,12 +2245,20 @@ function registerSafetyTool(pi, ctx) {
         list: "list_checkpoints"
       };
       const req = {};
-      if (params.filePath)
-        req.file = params.filePath;
       if (params.name)
         req.name = params.name;
-      if (params.files)
-        req.files = params.files;
+      if (params.op === "checkpoint") {
+        if (params.files) {
+          req.files = params.files;
+        } else if (params.filePath) {
+          req.files = [params.filePath];
+        }
+      } else {
+        if (params.filePath)
+          req.file = params.filePath;
+        if (params.files)
+          req.files = params.files;
+      }
       const response = await callBridge(bridge, commandMap[params.op], req);
       return textResult(JSON.stringify(response, null, 2));
     }
@@ -2145,7 +2360,7 @@ var PLUGIN_VERSION = (() => {
   }
 })();
 function resolveStorageDir() {
-  return join8(homedir5(), ".pi", "agent", "aft");
+  return join8(homedir6(), ".pi", "agent", "aft");
 }
 function resolveToolSurface(config) {
   const surface = config.tool_surface ?? "recommended";

package/dist/tools/diff-format.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Diff formatting helpers for Pi hoisted tool renderers.
+ *
+ * Mirrors the output shape Pi's built-in `renderDiff` expects:
+ *   "+NN content"   for added lines
+ *   "-NN content"   for removed lines
+ *   " NN content"   for context lines
+ *   " NN ..."       for context truncation markers
+ *
+ * We don't re-export Pi's internal `generateDiffString` because it isn't
+ * public. Reimplementing it as a thin wrapper around the `diff` npm package
+ * (also used by Pi itself) is ~40 lines and keeps us decoupled from Pi's
+ * private internals.
+ */
+export interface FormattedDiff {
+    diff: string;
+    firstChangedLine: number | undefined;
+}
+/**
+ * Generate a line-numbered diff string suitable for Pi's `renderDiff`.
+ * Matches the format of Pi's built-in edit tool result.
+ */
+export declare function formatDiffForPi(oldContent: string, newContent: string, contextLines?: number): FormattedDiff;
+//# sourceMappingURL=diff-format.d.ts.map

package/dist/tools/diff-format.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"diff-format.d.ts","sourceRoot":"","sources":["../../src/tools/diff-format.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAIH,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,gBAAgB,EAAE,MAAM,GAAG,SAAS,CAAC;CACtC;AAID;;;GAGG;AACH,wBAAgB,eAAe,CAC7B,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,MAAM,EAClB,YAAY,SAAwB,GACnC,aAAa,CAsGf"}

package/dist/tools/hoisted.d.ts

@@ -2,8 +2,21 @@
  * Hoisted tool overrides — replace Pi's built-in read/write/edit/grep with
  * AFT-backed Rust implementations. Registering a tool with the same name as
  * a built-in replaces the built-in entirely.
+ *
+ * Each tool provides:
+ *  - `promptSnippet` / `promptGuidelines`: teach the model our argument shape
+ *    in Pi's system prompt (Pi's built-ins use generic one-liners otherwise).
+ *  - `renderCall` / `renderResult` for `write` and `edit`: without these,
+ *    Pi's ToolExecutionComponent falls back to the *built-in* renderer for
+ *    same-named tools, which reads `path` and `edits[]` and garbles our
+ *    `filePath` / `oldString` / `newString` output (issue #15).
+ *  - Structured `details: { diff, firstChangedLine }` so the rendered diff
+ *    also ends up in the agent's message stream, matching Pi's convention.
+ *
+ * `read` and `grep` keep the default text-only result rendering because our
+ * payload (`path`, `pattern`) already aligns with Pi's built-in arg shape.
  */
-import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import { type AgentToolResult, type ExtensionAPI } from "@mariozechner/pi-coding-agent";
 import type { PluginContext } from "../types.js";
 export interface ToolSurfaceFlags {
     hoistRead: boolean;
@@ -11,5 +24,28 @@ export interface ToolSurfaceFlags {
     hoistEdit: boolean;
     hoistGrep: boolean;
 }
+/** Details surfaced to both renderer and agent message stream. */
+interface FileMutationDetails {
+    diff?: string;
+    firstChangedLine?: number;
+    additions: number;
+    deletions: number;
+    replacements?: number;
+    diagnostics?: unknown[];
+    /**
+     * True when Rust returned `diff.truncated = true` — the before/after strings
+     * were omitted because the file exceeded the diff size cap, so we have no
+     * line-level diff to render. Both the agent-facing text and the TUI renderer
+     * surface this explicitly rather than silently showing a summary.
+     */
+    truncated?: boolean;
+}
 export declare function registerHoistedTools(pi: ExtensionAPI, ctx: PluginContext, surface: ToolSurfaceFlags): void;
+/**
+ * Shape the bridge `edit_match` / `write` response into an `AgentToolResult`
+ * Pi can render. Exported for unit tests covering truncation and diagnostics
+ * behavior without spinning up a real bridge.
+ */
+export declare function buildMutationResult(filePath: string, response: Record<string, unknown>): AgentToolResult<FileMutationDetails>;
+export {};
 //# sourceMappingURL=hoisted.d.ts.map

package/dist/tools/hoisted.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"hoisted.d.ts","sourceRoot":"","sources":["../../src/tools/hoisted.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAC;AAElE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AA0CjD,MAAM,WAAW,gBAAgB;IAC/B,SAAS,EAAE,OAAO,CAAC;IACnB,UAAU,EAAE,OAAO,CAAC;IACpB,SAAS,EAAE,OAAO,CAAC;IACnB,SAAS,EAAE,OAAO,CAAC;CACpB;AAED,wBAAgB,oBAAoB,CAClC,EAAE,EAAE,YAAY,EAChB,GAAG,EAAE,aAAa,EAClB,OAAO,EAAE,gBAAgB,GACxB,IAAI,CAgJN"}
+{"version":3,"file":"hoisted.d.ts","sourceRoot":"","sources":["../../src/tools/hoisted.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAKH,OAAO,EACL,KAAK,eAAe,EACpB,KAAK,YAAY,EAGlB,MAAM,+BAA+B,CAAC;AAGvC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAqDjD,MAAM,WAAW,gBAAgB;IAC/B,SAAS,EAAE,OAAO,CAAC;IACnB,UAAU,EAAE,OAAO,CAAC;IACpB,SAAS,EAAE,OAAO,CAAC;IACnB,SAAS,EAAE,OAAO,CAAC;CACpB;AAED,kEAAkE;AAClE,UAAU,mBAAmB;IAC3B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,WAAW,CAAC,EAAE,OAAO,EAAE,CAAC;IACxB;;;;;OAKG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AAED,wBAAgB,oBAAoB,CAClC,EAAE,EAAE,YAAY,EAChB,GAAG,EAAE,aAAa,EAClB,OAAO,EAAE,gBAAgB,GACxB,IAAI,CA8IN;AAMD;;;;GAIG;AACH,wBAAgB,mBAAmB,CACjC,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAChC,eAAe,CAAC,mBAAmB,CAAC,CA6DtC"}

package/dist/tools/safety.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"safety.d.ts","sourceRoot":"","sources":["../../src/tools/safety.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAC;AAElE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAkBjD,wBAAgB,kBAAkB,CAAC,EAAE,EAAE,YAAY,EAAE,GAAG,EAAE,aAAa,GAAG,IAAI,CAoC7E"}
+{"version":3,"file":"safety.d.ts","sourceRoot":"","sources":["../../src/tools/safety.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAC;AAElE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAkBjD,wBAAgB,kBAAkB,CAAC,EAAE,EAAE,YAAY,EAAE,GAAG,EAAE,aAAa,GAAG,IAAI,CAkD7E"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cortexkit/aft-pi",
-  "version": "0.14.0",
+  "version": "0.14.1",
   "type": "module",
   "description": "Pi coding agent extension for Agent File Tools (AFT) — tree-sitter and LSP-powered code analysis",
   "main": "dist/index.js",
@@ -15,29 +15,32 @@
     "README.md"
   ],
   "scripts": {
-    "build": "bun build src/index.ts --outdir dist --target node --format esm --external @mariozechner/pi-coding-agent --external @mariozechner/pi-ai --external @mariozechner/pi-tui --external @sinclair/typebox && tsc --emitDeclarationOnly",
+    "build": "bun build src/index.ts --outdir dist --target node --format esm --external @mariozechner/pi-coding-agent --external @mariozechner/pi-ai --external @mariozechner/pi-tui --external @sinclair/typebox --external diff && tsc --emitDeclarationOnly",
     "typecheck": "tsc --noEmit",
     "test": "bun test src/__tests__/",
     "prepublishOnly": "bun run build"
   },
   "dependencies": {
-    "@sinclair/typebox": "^0.34.33"
+    "@sinclair/typebox": "^0.34.33",
+    "diff": "^8.0.4"
   },
   "optionalDependencies": {
-    "@cortexkit/aft-darwin-arm64": "0.14.0",
-    "@cortexkit/aft-darwin-x64": "0.14.0",
-    "@cortexkit/aft-linux-arm64": "0.14.0",
-    "@cortexkit/aft-linux-x64": "0.14.0",
-    "@cortexkit/aft-win32-x64": "0.14.0"
+    "@cortexkit/aft-darwin-arm64": "0.14.1",
+    "@cortexkit/aft-darwin-x64": "0.14.1",
+    "@cortexkit/aft-linux-arm64": "0.14.1",
+    "@cortexkit/aft-linux-x64": "0.14.1",
+    "@cortexkit/aft-win32-x64": "0.14.1"
   },
   "devDependencies": {
     "@mariozechner/pi-coding-agent": "*",
     "@mariozechner/pi-ai": "*",
+    "@mariozechner/pi-tui": "*",
     "@types/node": "^22.0.0",
     "typescript": "^5.8.0"
   },
   "peerDependencies": {
-    "@mariozechner/pi-coding-agent": "*"
+    "@mariozechner/pi-coding-agent": "*",
+    "@mariozechner/pi-tui": "*"
   },
   "exports": {
     ".": {