@aaroncql/pim-agent 0.1.0 → 0.3.0

package/src/shared/FileScanner.ts

@@ -1,5 +1,5 @@
-import { resolve } from "node:path";
-import { GitignoreFilter } from "./GitignoreFilter";
+import { join, resolve } from "node:path";
+import { FileEnumerator } from "./FileEnumerator";
 import { GlobExclusions } from "./GlobExclusions";
 
 export type FileScanOptions = {
@@ -15,25 +15,23 @@ export class FileScanner {
     options: FileScanOptions
   ): Promise<readonly string[]> {
     const absoluteRoot = resolve(root);
-    const filter = options.includeIgnored
-      ? undefined
-      : await GitignoreFilter.for(absoluteRoot);
+    const relativePaths = await FileEnumerator.enumerate(absoluteRoot, {
+      includeDotfiles: options.includeDotfiles,
+      includeIgnored: options.includeIgnored,
+    });
+    const matcher = new Bun.Glob(pattern);
     const excludes = GlobExclusions.compile(options.exclude);
-    const glob = new Bun.Glob(pattern);
     const files: string[] = [];
 
-    for await (const filePath of glob.scan({
-      cwd: absoluteRoot,
-      absolute: true,
-      onlyFiles: true,
-      dot: options.includeDotfiles,
-    })) {
-      if (
-        (filter === undefined || !filter.ignores(filePath)) &&
-        !GlobExclusions.ignores(excludes, absoluteRoot, filePath)
-      ) {
-        files.push(filePath);
+    for (const relativePath of relativePaths) {
+      if (!matcher.match(relativePath)) {
+        continue;
       }
+      const absolutePath = join(absoluteRoot, relativePath);
+      if (GlobExclusions.ignores(excludes, absoluteRoot, absolutePath)) {
+        continue;
+      }
+      files.push(absolutePath);
     }
 
     return files;

package/src/shared/PatchSummary.ts

@@ -0,0 +1,82 @@
+export type PatchOp = {
+  readonly kind: "add" | "delete" | "update";
+  readonly path: string;
+  readonly movePath?: string;
+};
+
+const MOVE_TO_MARKER = "*** Move to:";
+const FILE_MARKERS: ReadonlyArray<readonly [PatchOp["kind"], string]> = [
+  ["add", "*** Add File: "],
+  ["delete", "*** Delete File: "],
+  ["update", "*** Update File: "],
+];
+
+type MutableOp = {
+  readonly kind: PatchOp["kind"];
+  readonly path: string;
+  movePath?: string;
+};
+
+/**
+ * Lightweight, fault-tolerant scan of V4A patch text into a per-file summary.
+ * For renderers that need to label a patch without depending on the apply-patch
+ * grammar parser; unrecognized lines are ignored rather than throwing.
+ */
+export class PatchSummary {
+  public static fromText(input: string): readonly PatchOp[] {
+    const ops: MutableOp[] = [];
+
+    for (const raw of input.split("\n")) {
+      const line = raw.trim();
+      const op = PatchSummary.fileOp(line);
+      if (op) {
+        ops.push(op);
+      } else if (line.startsWith(MOVE_TO_MARKER)) {
+        const current = ops.at(-1);
+        if (current?.kind === "update") {
+          current.movePath = PatchSummary.clean(
+            line.slice(MOVE_TO_MARKER.length)
+          );
+        }
+      }
+    }
+
+    return ops;
+  }
+
+  // The first affected path, without building the full per-file summary — for
+  // callers that only need a title (e.g. a tool-call header on the render path).
+  public static firstPath(input: string): string | undefined {
+    for (const raw of input.split("\n")) {
+      const op = PatchSummary.fileOp(raw.trim());
+      if (op) {
+        return op.path;
+      }
+    }
+    return undefined;
+  }
+
+  private static fileOp(line: string): MutableOp | undefined {
+    for (const [kind, marker] of FILE_MARKERS) {
+      if (line.startsWith(marker)) {
+        return { kind, path: PatchSummary.clean(line.slice(marker.length)) };
+      }
+    }
+    return undefined;
+  }
+
+  private static clean(raw: string): string {
+    let path = raw.trim();
+    if (path.startsWith("@")) {
+      path = path.slice(1).trim();
+    }
+    if (path.length >= 2) {
+      const first = path[0]!;
+      const last = path.at(-1)!;
+      if ((first === '"' || first === "'" || first === "`") && first === last) {
+        path = path.slice(1, -1);
+      }
+    }
+    return path;
+  }
+}

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/shared/GitignoreFilter.ts

@@ -1,142 +0,0 @@
-import { readFile, stat } from "node:fs/promises";
-import { dirname, isAbsolute, parse, relative, resolve } from "node:path";
-import ignore, { type Ignore } from "ignore";
-import { FsErrors } from "./FsErrors";
-import { Paths } from "./Paths";
-
-type IgnoreMatcher = {
-  readonly baseDirectory: string;
-  readonly matcher: Ignore;
-};
-
-export class GitignoreFilter {
-  private static readonly alwaysIgnoredPatterns = [
-    ".git/",
-    "node_modules/",
-    "dist/",
-    "build/",
-    "out/",
-    "target/",
-    "coverage/",
-    ".next/",
-    ".cache/",
-    ".turbo/",
-    ".vercel/",
-    ".svelte-kit/",
-  ] as const;
-
-  private readonly matchers: readonly IgnoreMatcher[];
-
-  private constructor(matchers: readonly IgnoreMatcher[]) {
-    this.matchers = matchers;
-  }
-
-  public static async for(root: string): Promise<GitignoreFilter> {
-    const absoluteRoot = resolve(root);
-    const rootDirectory =
-      await GitignoreFilter.containingDirectory(absoluteRoot);
-    const directories =
-      await GitignoreFilter.gitignoreDirectories(rootDirectory);
-    const contents = await Promise.all(
-      directories.map((directory) => GitignoreFilter.readGitignore(directory))
-    );
-    const matchers: IgnoreMatcher[] = [
-      {
-        baseDirectory: rootDirectory,
-        matcher: ignore().add([...GitignoreFilter.alwaysIgnoredPatterns]),
-      },
-    ];
-
-    for (const [index, directory] of directories.entries()) {
-      const body = contents[index];
-
-      if (body !== undefined) {
-        matchers.push({
-          baseDirectory: directory,
-          matcher: ignore().add(body),
-        });
-      }
-    }
-
-    return new GitignoreFilter(matchers);
-  }
-
-  public ignores(absolutePath: string): boolean {
-    if (!isAbsolute(absolutePath)) {
-      throw new Error(`Expected absolute path: ${absolutePath}`);
-    }
-
-    for (const { baseDirectory, matcher } of this.matchers) {
-      const candidate = this.relativePath(baseDirectory, absolutePath);
-
-      if (candidate !== undefined && matcher.ignores(candidate)) {
-        return true;
-      }
-    }
-
-    return false;
-  }
-
-  private static async containingDirectory(path: string): Promise<string> {
-    const metadata = await stat(path);
-
-    return metadata.isDirectory() ? path : dirname(path);
-  }
-
-  private static async gitignoreDirectories(
-    root: string
-  ): Promise<readonly string[]> {
-    const directories: string[] = [];
-    const filesystemRoot = parse(root).root;
-    let current = root;
-
-    while (true) {
-      directories.push(current);
-
-      if (await Bun.file(resolve(current, ".git")).exists()) {
-        break;
-      }
-
-      if (current === filesystemRoot) {
-        break;
-      }
-
-      current = dirname(current);
-    }
-
-    return directories;
-  }
-
-  private static async readGitignore(
-    directory: string
-  ): Promise<string | undefined> {
-    const path = resolve(directory, ".gitignore");
-
-    try {
-      return await readFile(path, "utf8");
-    } catch (error) {
-      if (FsErrors.code(error) === "ENOENT") {
-        return undefined;
-      }
-
-      throw error;
-    }
-  }
-
-  private relativePath(
-    baseDirectory: string,
-    absolutePath: string
-  ): string | undefined {
-    const candidate = relative(baseDirectory, absolutePath);
-
-    if (
-      candidate.length === 0 ||
-      candidate.startsWith("..") ||
-      isAbsolute(candidate)
-    ) {
-      return undefined;
-    }
-
-    return Paths.toForwardSlashes(candidate);
-  }
-}