@aaroncql/pim-agent 0.0.1 → 0.2.0

package/src/telegram/Renderer.ts

@@ -2,8 +2,12 @@ import type { AgentSessionEvent } from "@earendil-works/pi-coding-agent";
 import { GrammyError, type Api } from "grammy";
 import { basename } from "node:path";
 
+import type { ApplyEntry } from "../extensions/apply-patch/executor";
 import type { SubagentDetails } from "../extensions/subagent/subagent";
 import type { TodoInput } from "../extensions/todo/schema";
+import type { ToolDiff } from "../shared/DiffLines";
+import { DiffView, type DiffStats } from "../shared/DiffView";
+import { type PatchOp, PatchSummary } from "../shared/PatchSummary";
 import type { LogsMode } from "./Config";
 import { Markdown } from "./Markdown";
 import type { Session, SessionId } from "./Session";
@@ -15,15 +19,30 @@ type TurnState = TurnEndState | "running";
 type TrackerEntry = {
   readonly key: string;
   readonly kind: "tool" | "todo" | "thinking" | "narration";
-  readonly emoji: string;
+  emoji: string;
   label: string;
   state: "running" | "ok" | "error";
+  // Plaintext "+4/-3" appended after the label once the tool finishes.
+  stats?: string;
 };
 
+type ApplyOp = {
+  readonly emoji: string;
+  readonly text: string;
+};
+
+const EDIT_EMOJI = "✏️";
+const DELETE_EMOJI = "🗑️";
+const ARROW = "➝";
+
+// Keys an apply_patch tool call may carry its patch text under (canonical first).
+const PATCH_TEXT_KEYS = ["input", "patch", "patchText", "patch_text"] as const;
+
 const TOOL_EMOJI: Record<string, string> = {
   read: "📄",
-  edit: "✏️",
-  write: "✏️",
+  edit: EDIT_EMOJI,
+  write: EDIT_EMOJI,
+  apply_patch: EDIT_EMOJI,
   bash: "⚡️",
   grep: "🔎",
   glob: "🔎",
@@ -130,6 +149,9 @@ export class Renderer {
         return;
       }
       this.updateSubagentLabel(event.toolCallId, event.toolName, event.result);
+      if (!event.isError) {
+        this.applyDiffStats(event.toolCallId, event.toolName, event.result);
+      }
       const idx = this.toolIndex.get(event.toolCallId);
       if (idx !== undefined) {
         this.entries[idx]!.state = event.isError ? "error" : "ok";
@@ -179,6 +201,21 @@ export class Renderer {
       this.scheduleEdit();
       return;
     }
+    if (name === "apply_patch") {
+      const { emoji, label } = Renderer.buildApplyEntry(
+        Renderer.applyOpsFromArgs(args)
+      );
+      this.entries.push({
+        key: toolCallId,
+        kind: "tool",
+        emoji,
+        label,
+        state: "running",
+      });
+      this.toolIndex.set(toolCallId, this.entries.length - 1);
+      this.scheduleEdit();
+      return;
+    }
     const emoji = TOOL_EMOJI[name] ?? "⚙️";
     const label = Renderer.toolLabel(toolName, args);
     if (name === "subagent") {
@@ -234,6 +271,42 @@ export class Renderer {
     this.scheduleEdit();
   }
 
+  private applyDiffStats(
+    toolCallId: string,
+    toolName: string,
+    result: unknown
+  ): void {
+    const idx = this.toolIndex.get(toolCallId);
+    if (idx === undefined) {
+      return;
+    }
+    const name = toolName.toLowerCase();
+    const details = (result as { readonly details?: unknown } | null)?.details;
+    if (name === "edit" || name === "write") {
+      const diff = (details as { readonly diff?: ToolDiff } | undefined)?.diff;
+      const stats = Renderer.formatPlainStats(DiffView.countStats(diff));
+      if (stats) {
+        this.entries[idx]!.stats = stats;
+        this.scheduleEdit();
+      }
+      return;
+    }
+    if (name === "apply_patch") {
+      const entries = (
+        details as { readonly entries?: readonly ApplyEntry[] } | undefined
+      )?.entries;
+      if (!entries) {
+        return;
+      }
+      const built = Renderer.buildApplyEntry(
+        Renderer.applyOpsFromEntries(entries)
+      );
+      this.entries[idx]!.emoji = built.emoji;
+      this.entries[idx]!.label = built.label;
+      this.scheduleEdit();
+    }
+  }
+
   private flushThinking(): void {
     if (this.logsMode !== "verbose") {
       this.thinking = "";
@@ -370,7 +443,8 @@ export class Renderer {
         } else if (state === "running" && isLastEntry) {
           suffix = " 🟡";
         }
-        pieces.push(`${entry.emoji} ${entry.label}${suffix}`);
+        const stats = entry.stats ? ` ${entry.stats}` : "";
+        pieces.push(`${entry.emoji} ${entry.label}${stats}${suffix}`);
       }
       const next = visible[i + 1];
       if (next) {
@@ -490,6 +564,118 @@ export class Renderer {
     }
   }
 
+  private static buildApplyEntry(ops: readonly ApplyOp[]): {
+    readonly emoji: string;
+    readonly label: string;
+  } {
+    const [first, ...rest] = ops;
+    if (!first) {
+      return { emoji: EDIT_EMOJI, label: "" };
+    }
+    const label = [
+      first.text,
+      ...rest.map((op) => `${op.emoji} ${op.text}`),
+    ].join("\n");
+    return { emoji: first.emoji, label };
+  }
+
+  private static applyOpsFromArgs(args: unknown): readonly ApplyOp[] {
+    const text = Renderer.patchTextFromArgs(args);
+    if (!text) {
+      return [];
+    }
+    return PatchSummary.fromText(text).map((op) => Renderer.opFromSummary(op));
+  }
+
+  private static applyOpsFromEntries(
+    entries: readonly ApplyEntry[]
+  ): readonly ApplyOp[] {
+    return entries
+      .filter(
+        (entry) => !(entry.action.kind === "update" && entry.diff === undefined)
+      )
+      .map((entry) => Renderer.opFromEntry(entry));
+  }
+
+  private static opFromSummary(op: PatchOp): ApplyOp {
+    const isMove = op.movePath !== undefined && op.movePath !== op.path;
+    return Renderer.applyOp({
+      kind: isMove ? "move" : op.kind,
+      path: op.path,
+      movePath: op.movePath,
+    });
+  }
+
+  private static opFromEntry(entry: ApplyEntry): ApplyOp {
+    return Renderer.applyOp({
+      kind: entry.action.kind,
+      path: entry.action.path,
+      movePath: entry.action.movePath,
+      stats: Renderer.formatPlainStats(DiffView.countStats(entry.diff)),
+    });
+  }
+
+  private static applyOp(params: {
+    readonly kind: "add" | "delete" | "move" | "update";
+    readonly path: string;
+    readonly movePath?: string;
+    readonly stats?: string;
+  }): ApplyOp {
+    const suffix = params.stats ? ` ${params.stats}` : "";
+    if (params.kind === "delete") {
+      return {
+        emoji: DELETE_EMOJI,
+        text: `${Renderer.codeName(params.path)}${suffix}`,
+      };
+    }
+    if (params.kind === "move") {
+      return {
+        emoji: EDIT_EMOJI,
+        text: `${Renderer.moveText(params.path, params.movePath ?? params.path)}${suffix}`,
+      };
+    }
+    return {
+      emoji: EDIT_EMOJI,
+      text: `${Renderer.codeName(params.path)}${suffix}`,
+    };
+  }
+
+  private static moveText(from: string, to: string): string {
+    return `${Renderer.codeName(from)} ${ARROW} ${Renderer.codeName(to)}`;
+  }
+
+  private static codeName(path: string): string {
+    return `<code>${Markdown.escape(basename(path))}</code>`;
+  }
+
+  private static patchTextFromArgs(args: unknown): string | undefined {
+    if (typeof args === "string") {
+      return args;
+    }
+    if (!args || typeof args !== "object") {
+      return undefined;
+    }
+    const record = args as Record<string, unknown>;
+    for (const key of PATCH_TEXT_KEYS) {
+      const value = record[key];
+      if (typeof value === "string" && value) {
+        return value;
+      }
+    }
+    return undefined;
+  }
+
+  private static formatPlainStats(stats: DiffStats): string {
+    const parts: string[] = [];
+    if (stats.added > 0) {
+      parts.push(`+${stats.added}`);
+    }
+    if (stats.removed > 0) {
+      parts.push(`-${stats.removed}`);
+    }
+    return parts.join("/");
+  }
+
   private static toolLabel(toolName: string, args: unknown): string {
     const obj =
       args && typeof args === "object" ? (args as Record<string, unknown>) : {};

package/src/extensions/bash/capture.test.ts

@@ -1,126 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { concat, StreamCapture } from "./capture";
-import { STREAM_HEAD_BYTES, STREAM_TAIL_BYTES } from "./schema";
-
-const enc = new TextEncoder();
-const u8 = (s: string) => enc.encode(s);
-
-describe("concat", () => {
-  test("merges multiple chunks in order", () => {
-    const out = concat([u8("foo"), u8("bar")], 6);
-    expect(new TextDecoder().decode(out)).toBe("foobar");
-  });
-
-  test("returns empty array when total is 0", () => {
-    expect(concat([], 0).byteLength).toBe(0);
-  });
-});
-
-describe("StreamCapture", () => {
-  test("empty capture", () => {
-    const c = new StreamCapture();
-    expect(c.snapshot()).toEqual({
-      text: "",
-      totalBytes: 0,
-      truncated: false,
-      path: null,
-      nextStart: null,
-    });
-  });
-
-  test("ignores zero-byte chunks", () => {
-    const c = new StreamCapture();
-    c.push(new Uint8Array(0));
-    c.push(u8("hi"));
-    expect(c.snapshot()).toEqual({
-      text: "hi",
-      totalBytes: 2,
-      truncated: false,
-      path: null,
-      nextStart: null,
-    });
-  });
-
-  test("does not truncate when within head+tail budget", () => {
-    const c = new StreamCapture();
-    c.push(u8("hello"));
-    c.push(u8(" world"));
-    expect(c.snapshot()).toEqual({
-      text: "hello world",
-      totalBytes: 11,
-      truncated: false,
-      path: null,
-      nextStart: null,
-    });
-  });
-
-  test("truncates middle when over budget", () => {
-    const c = new StreamCapture();
-    const headChunk = "A".repeat(STREAM_HEAD_BYTES);
-    const middleChunk = "X".repeat(1000);
-    const tailChunk = "B".repeat(STREAM_TAIL_BYTES);
-    c.push(u8(headChunk));
-    c.push(u8(middleChunk));
-    c.push(u8(tailChunk));
-
-    const snap = c.snapshot();
-    expect(snap.truncated).toBe(true);
-    expect(snap.totalBytes).toBe(STREAM_HEAD_BYTES + 1000 + STREAM_TAIL_BYTES);
-    expect(snap.text.startsWith(headChunk)).toBe(true);
-    expect(snap.text.endsWith(tailChunk)).toBe(true);
-    expect(snap.text).toContain(`... ${1000} bytes truncated ...`);
-    expect(snap.nextStart).toBe(1);
-  });
-
-  test("reports the resume line at the end of the head when truncated", () => {
-    const c = new StreamCapture();
-    const lineBytes = STREAM_HEAD_BYTES / 4;
-    const headChunk = `${"A".repeat(lineBytes - 1)}\n`.repeat(4);
-    c.push(u8(headChunk));
-    c.push(u8("X".repeat(1000)));
-    c.push(u8("B".repeat(STREAM_TAIL_BYTES)));
-
-    const snap = c.snapshot();
-    expect(snap.truncated).toBe(true);
-    // Head holds exactly 4 newline-terminated lines, so reading resumes at 5.
-    expect(snap.nextStart).toBe(5);
-  });
-
-  test("splits a single chunk between head and tail when needed", () => {
-    const c = new StreamCapture();
-    const big = "Z".repeat(STREAM_HEAD_BYTES + STREAM_TAIL_BYTES + 500);
-    c.push(u8(big));
-
-    const snap = c.snapshot();
-    expect(snap.truncated).toBe(true);
-    expect(snap.totalBytes).toBe(big.length);
-    expect(snap.text.startsWith("Z".repeat(STREAM_HEAD_BYTES))).toBe(true);
-    expect(snap.text.endsWith("Z".repeat(STREAM_TAIL_BYTES))).toBe(true);
-    expect(snap.text).toContain(`... ${500} bytes truncated ...`);
-  });
-
-  test("keeps head and final tail when many middle chunks arrive", () => {
-    const c = new StreamCapture();
-    const HEAD_FILL = "A".repeat(STREAM_HEAD_BYTES);
-    c.push(u8(HEAD_FILL));
-    for (let i = 0; i < 100; i++) {
-      c.push(u8("M".repeat(STREAM_TAIL_BYTES)));
-    }
-    const finalTail = "B".repeat(STREAM_TAIL_BYTES);
-    c.push(u8(finalTail));
-
-    const snap = c.snapshot();
-    expect(snap.truncated).toBe(true);
-    expect(snap.text.startsWith(HEAD_FILL)).toBe(true);
-    expect(snap.text.endsWith(finalTail)).toBe(true);
-  });
-
-  test("at exact head+tail boundary is not truncated", () => {
-    const c = new StreamCapture();
-    c.push(u8("A".repeat(STREAM_HEAD_BYTES)));
-    c.push(u8("B".repeat(STREAM_TAIL_BYTES)));
-    const snap = c.snapshot();
-    expect(snap.truncated).toBe(false);
-    expect(snap.totalBytes).toBe(STREAM_HEAD_BYTES + STREAM_TAIL_BYTES);
-  });
-});

package/src/extensions/bash/format.test.ts

@@ -1,240 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import {
-  detailsOf,
-  formatResult,
-  formatTruncationAffordance,
-  isErrorResult,
-  stripTrailingNewline,
-} from "./format";
-import {
-  type BashCommandResult,
-  STREAM_HEAD_BYTES,
-  STREAM_TAIL_BYTES,
-} from "./schema";
-
-function makeResult(
-  overrides: Partial<BashCommandResult> = {}
-): BashCommandResult {
-  return {
-    exitCode: 0,
-    signal: null,
-    stdout: {
-      text: "",
-      totalBytes: 0,
-      truncated: false,
-      path: null,
-      nextStart: null,
-    },
-    stderr: {
-      text: "",
-      totalBytes: 0,
-      truncated: false,
-      path: null,
-      nextStart: null,
-    },
-    timedOut: false,
-    aborted: false,
-    durationMs: 1,
-    ...overrides,
-  };
-}
-
-describe("stripTrailingNewline", () => {
-  test("removes one trailing newline", () => {
-    expect(stripTrailingNewline("foo\n")).toBe("foo");
-  });
-  test("leaves no-newline strings alone", () => {
-    expect(stripTrailingNewline("foo")).toBe("foo");
-  });
-  test("only strips one", () => {
-    expect(stripTrailingNewline("foo\n\n")).toBe("foo\n");
-  });
-});
-
-describe("formatTruncationAffordance", () => {
-  test("emits bracketed affordance with byte counts and next-step", () => {
-    const out = formatTruncationAffordance("stderr", {
-      text: "x",
-      totalBytes: 12345,
-      truncated: true,
-      path: null,
-      nextStart: 1,
-    });
-    expect(out.startsWith("[bash tool:")).toBe(true);
-    expect(out.endsWith("]")).toBe(true);
-    expect(out).toContain("stderr showing first");
-    expect(out).toContain(`first ${STREAM_HEAD_BYTES} bytes`);
-    expect(out).toContain(`last ${STREAM_TAIL_BYTES} bytes`);
-    expect(out).toContain("of 12345");
-    expect(out).toContain("redirect to a file");
-    expect(out).toContain("read");
-  });
-
-  test("points to spill path with a resume line when one is provided", () => {
-    const out = formatTruncationAffordance("stdout", {
-      text: "x",
-      totalBytes: 99999,
-      truncated: true,
-      path: "/tmp/pim-bash-abc.out",
-      nextStart: 42,
-    });
-    expect(out).toContain(
-      "use read with path=/tmp/pim-bash-abc.out and start=42 for the rest."
-    );
-    expect(out).not.toContain("redirect to a file");
-  });
-});
-
-describe("formatResult", () => {
-  test("happy path with stdout only", () => {
-    const out = formatResult(
-      makeResult({
-        stdout: {
-          text: "hello\n",
-          totalBytes: 6,
-          truncated: false,
-          path: null,
-          nextStart: null,
-        },
-      }),
-      30_000
-    );
-    expect(out).toBe("Exit code: 0\nstdout:\nhello");
-  });
-
-  test("includes signal line when signal present", () => {
-    const out = formatResult(
-      makeResult({ exitCode: null, signal: "SIGTERM" }),
-      30_000
-    );
-    expect(out).toContain("Exit code: none");
-    expect(out).toContain("Signal: SIGTERM");
-  });
-
-  test("aborted overrides timed out message", () => {
-    const out = formatResult(
-      makeResult({ aborted: true, timedOut: true }),
-      30_000
-    );
-    expect(out).toContain("Aborted.");
-    expect(out).not.toContain("Timed out");
-  });
-
-  test("timed out adds duration message", () => {
-    const out = formatResult(makeResult({ timedOut: true }), 5000);
-    expect(out).toContain("Timed out after 5000 ms.");
-  });
-
-  test("includes both stdout and stderr when both have bytes", () => {
-    const out = formatResult(
-      makeResult({
-        exitCode: 1,
-        stdout: {
-          text: "out",
-          totalBytes: 3,
-          truncated: false,
-          path: null,
-          nextStart: null,
-        },
-        stderr: {
-          text: "err",
-          totalBytes: 3,
-          truncated: false,
-          path: null,
-          nextStart: null,
-        },
-      }),
-      30_000
-    );
-    expect(out).toBe("Exit code: 1\nstdout:\nout\nstderr:\nerr");
-  });
-
-  test("appends bracket affordance after a truncated stream body", () => {
-    const out = formatResult(
-      makeResult({
-        stdout: {
-          text: "head…tail",
-          totalBytes: 99999,
-          truncated: true,
-          path: null,
-          nextStart: 1,
-        },
-      }),
-      30_000
-    );
-    const lines = out.split("\n");
-    expect(lines[0]).toBe("Exit code: 0");
-    expect(lines[1]).toBe("stdout:");
-    expect(lines[2]).toBe("head…tail");
-    expect(lines[3]?.startsWith("[bash tool: stdout showing first")).toBe(true);
-    expect(lines[3]?.endsWith("]")).toBe(true);
-  });
-
-  test("does not append affordance when stream is not truncated", () => {
-    const out = formatResult(
-      makeResult({
-        stdout: {
-          text: "ok",
-          totalBytes: 2,
-          truncated: false,
-          path: null,
-          nextStart: null,
-        },
-      }),
-      30_000
-    );
-    expect(out).not.toContain("[bash tool:");
-  });
-});
-
-describe("detailsOf", () => {
-  test("mirrors per-stream truncation and byte counts", () => {
-    const details = detailsOf(
-      makeResult({
-        exitCode: 1,
-        durationMs: 42,
-        stdout: {
-          text: "x",
-          totalBytes: 99999,
-          truncated: true,
-          path: null,
-          nextStart: 1,
-        },
-        stderr: {
-          text: "y",
-          totalBytes: 5,
-          truncated: false,
-          path: null,
-          nextStart: null,
-        },
-      })
-    );
-    expect(details).toEqual({
-      exitCode: 1,
-      signal: null,
-      durationMs: 42,
-      timedOut: false,
-      aborted: false,
-      stdout: { totalBytes: 99999, truncated: true, path: null },
-      stderr: { totalBytes: 5, truncated: false, path: null },
-    });
-  });
-});
-
-describe("isErrorResult", () => {
-  test("zero exit code is not an error", () => {
-    expect(isErrorResult(makeResult({ exitCode: 0 }))).toBe(false);
-  });
-  test("non-zero exit code is an error", () => {
-    expect(isErrorResult(makeResult({ exitCode: 1 }))).toBe(true);
-  });
-  test("null exit code is an error", () => {
-    expect(isErrorResult(makeResult({ exitCode: null }))).toBe(true);
-  });
-  test("aborted is an error", () => {
-    expect(isErrorResult(makeResult({ aborted: true }))).toBe(true);
-  });
-  test("timed out is an error", () => {
-    expect(isErrorResult(makeResult({ timedOut: true }))).toBe(true);
-  });
-});