feat(agent): add file content caching and console log forwarding (#1135)

Add file content caching for Read/Write tool results to enable full-file diffs in cloud runs. This wires up console log forwarding to log writer as well.

Author: tatoalo

packages/agent/src/adapters/claude/conversion/sdk-to-acp.ts

@@ -192,6 +192,7 @@ function handleToolUseChunk(
   const toolInfo = toolInfoFromToolUse(chunk, {
     supportsTerminalOutput: ctx.supportsTerminalOutput,
     toolUseId: chunk.id,
+    cachedFileContent: ctx.fileContentCache,
   });
 
   const meta: Record<string, unknown> = {
@@ -221,6 +222,66 @@ function handleToolUseChunk(
   };
 }
 
+function extractTextFromContent(content: unknown): string | null {
+  if (Array.isArray(content)) {
+    const parts: string[] = [];
+    for (const item of content) {
+      if (
+        typeof item === "object" &&
+        item !== null &&
+        "text" in item &&
+        typeof (item as Record<string, unknown>).text === "string"
+      ) {
+        parts.push((item as { text: string }).text);
+      }
+    }
+    return parts.length > 0 ? parts.join("") : null;
+  }
+  if (typeof content === "string") {
+    return content;
+  }
+  return null;
+}
+
+function stripCatLineNumbers(text: string): string {
+  return text.replace(/^ *\d+[\t→]/gm, "");
+}
+
+function updateFileContentCache(
+  toolUse: { name: string; input: unknown },
+  chunk: { content?: unknown },
+  ctx: ChunkHandlerContext,
+): void {
+  const input = toolUse.input as Record<string, unknown> | undefined;
+  const filePath = input?.file_path ? String(input.file_path) : undefined;
+  if (!filePath) return;
+
+  if (toolUse.name === "Read" && !input?.limit && !input?.offset) {
+    const fileText = extractTextFromContent(chunk.content);
+    if (fileText !== null) {
+      ctx.fileContentCache[filePath] = stripCatLineNumbers(fileText);
+    }
+  } else if (toolUse.name === "Write") {
+    const content = input?.content;
+    if (typeof content === "string") {
+      ctx.fileContentCache[filePath] = content;
+    }
+  } else if (toolUse.name === "Edit") {
+    const oldString = input?.old_string;
+    const newString = input?.new_string;
+    if (
+      typeof oldString === "string" &&
+      typeof newString === "string" &&
+      filePath in ctx.fileContentCache
+    ) {
+      const current = ctx.fileContentCache[filePath];
+      ctx.fileContentCache[filePath] = input?.replace_all
+        ? current.replaceAll(oldString, newString)
+        : current.replace(oldString, newString);
+    }
+  }
+}
+
 function handleToolResultChunk(
   chunk: AnthropicContentChunk & {
     tool_use_id: string;
@@ -241,12 +302,17 @@ function handleToolResultChunk(
     return [];
   }
 
+  if (!chunk.is_error) {
+    updateFileContentCache(toolUse, chunk, ctx);
+  }
+
   const { _meta: resultMeta, ...toolUpdate } = toolUpdateFromToolResult(
     chunk as Parameters<typeof toolUpdateFromToolResult>[0],
     toolUse,
     {
       supportsTerminalOutput: ctx.supportsTerminalOutput,
       toolUseId: chunk.tool_use_id,
+      cachedFileContent: ctx.fileContentCache,
     },
   );
 

packages/agent/src/adapters/claude/conversion/tool-use-to-acp.ts

@@ -34,7 +34,11 @@ type ToolInfo = Pick<ToolCall, "title" | "kind" | "content" | "locations">;
 
 export function toolInfoFromToolUse(
   toolUse: Pick<ToolUseBlock, "name" | "input">,
-  options?: { supportsTerminalOutput?: boolean; toolUseId?: string },
+  options?: {
+    supportsTerminalOutput?: boolean;
+    toolUseId?: string;
+    cachedFileContent?: Record<string, string>;
+  },
 ): ToolInfo {
   const name = toolUse.name;
   const input = toolUse.input as Record<string, unknown> | undefined;
@@ -144,8 +148,24 @@ export function toolInfoFromToolUse(
 
     case "Edit": {
       const path = input?.file_path ? String(input.file_path) : undefined;
-      const oldText = input?.old_string ? String(input.old_string) : null;
-      const newText = input?.new_string ? String(input.new_string) : "";
+      let oldText: string | null = input?.old_string
+        ? String(input.old_string)
+        : null;
+      let newText: string = input?.new_string ? String(input.new_string) : "";
+
+      // If we have cached file content, show a full-file diff
+      if (
+        path &&
+        options?.cachedFileContent &&
+        path in options.cachedFileContent
+      ) {
+        const oldContent = options.cachedFileContent[path];
+        const newContent = input?.replace_all
+          ? oldContent.replaceAll(oldText ?? "", newText)
+          : oldContent.replace(oldText ?? "", newText);
+        oldText = oldContent;
+        newText = newContent;
+      }
 
       return {
         title: path ? `Edit \`${path}\`` : "Edit",
@@ -170,8 +190,12 @@ export function toolInfoFromToolUse(
       const filePath = input?.file_path ? String(input.file_path) : undefined;
       const contentStr = input?.content ? String(input.content) : undefined;
       if (filePath) {
+        const oldContent =
+          options?.cachedFileContent && filePath in options.cachedFileContent
+            ? options.cachedFileContent[filePath]
+            : null;
         contentResult = toolContent()
-          .diff(filePath, null, contentStr ?? "")
+          .diff(filePath, oldContent, contentStr ?? "")
           .build();
       } else if (contentStr) {
         contentResult = toolContent().text(contentStr).build();
@@ -453,7 +477,11 @@ export function toolUpdateFromToolResult(
     | BetaRequestMCPToolResultBlockParam
     | BetaToolSearchToolResultBlockParam,
   toolUse: Pick<ToolUseBlock, "name" | "input"> | undefined,
-  options?: { supportsTerminalOutput?: boolean; toolUseId?: string },
+  options?: {
+    supportsTerminalOutput?: boolean;
+    toolUseId?: string;
+    cachedFileContent?: Record<string, string>;
+  },
 ): Pick<ToolCallUpdate, "title" | "content" | "locations" | "_meta"> {
   if (
     "is_error" in toolResult &&

packages/agent/src/server/agent-server.ts

@@ -17,6 +17,7 @@ import { TreeTracker } from "../tree-tracker.js";
 import type {
   AgentMode,
   DeviceInfo,
+  LogLevel,
   TaskRun,
   TreeSnapshotEvent,
 } from "../types.js";
@@ -155,6 +156,35 @@ export class AgentServer {
   private questionRelayedToSlack = false;
   private detectedPrUrl: string | null = null;
 
+  private emitConsoleLog = (
+    level: LogLevel,
+    _scope: string,
+    message: string,
+    data?: unknown,
+  ): void => {
+    if (!this.session) return;
+
+    const formatted =
+      data !== undefined ? `${message} ${JSON.stringify(data)}` : message;
+
+    const notification = {
+      jsonrpc: "2.0",
+      method: POSTHOG_NOTIFICATIONS.CONSOLE,
+      params: { level, message: formatted },
+    };
+
+    this.broadcastEvent({
+      type: "notification",
+      timestamp: new Date().toISOString(),
+      notification,
+    });
+
+    this.session.logWriter.appendRawLine(
+      this.session.payload.run_id,
+      JSON.stringify(notification),
+    );
+  };
+
   constructor(config: AgentServerConfig) {
     this.config = config;
     this.logger = new Logger({ debug: true, prefix: "[AgentServer]" });
@@ -590,6 +620,17 @@ export class AgentServer {
       logWriter,
     };
 
+    this.logger = new Logger({
+      debug: true,
+      prefix: "[AgentServer]",
+      onLog: (level, scope, message, data) => {
+        // Preserve console output (onLog suppresses default console.*)
+        const _formatted =
+          data !== undefined ? `${message} ${JSON.stringify(data)}` : message;
+        this.emitConsoleLog(level, scope, message, data);
+      },
+    });
+
     this.logger.info("Session initialized successfully");
 
     // Signal in_progress so the UI can start polling for updates
@@ -1103,15 +1144,29 @@ Important:
           ...snapshot,
           device: this.session.deviceInfo,
         };
+
+        const notification = {
+          jsonrpc: "2.0" as const,
+          method: POSTHOG_NOTIFICATIONS.TREE_SNAPSHOT,
+          params: snapshotWithDevice,
+        };
+
         this.broadcastEvent({
           type: "notification",
           timestamp: new Date().toISOString(),
-          notification: {
-            jsonrpc: "2.0",
-            method: POSTHOG_NOTIFICATIONS.TREE_SNAPSHOT,
-            params: snapshotWithDevice,
-          },
+          notification,
         });
+
+        // Persist to log writer so cloud runs have tree snapshots
+        const { archiveUrl: _, ...paramsWithoutArchive } = snapshotWithDevice;
+        const logNotification = {
+          ...notification,
+          params: paramsWithoutArchive,
+        };
+        this.session.logWriter.appendRawLine(
+          this.session.payload.run_id,
+          JSON.stringify(logNotification),
+        );
       }
     } catch (error) {
       this.logger.error("Failed to capture tree state", error);