Extract originalFile from tool results for remote session support

When viewing sessions from remote URLs (like gists), the local filesystem
isn't available to read initial file content before edits. This change
extracts the originalFile field from toolUseResult in JSONL sessions and
uses it as a fallback when reconstructing file state.

- Add original_content field to FileOperation dataclass
- Extract originalFile from toolUseResult entries in extract_file_operations()
- Use original_content as fallback in build_file_history_repo() when file
  doesn't exist locally
- Add test coverage for originalFile extraction

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: btucker

src/claude_code_transcripts/code_view.py

@@ -70,6 +70,10 @@ class FileOperation:
     new_string: Optional[str] = None
     replace_all: bool = False
 
+    # Original file content from tool result (for Edit operations)
+    # This allows reconstruction without local file access
+    original_content: Optional[str] = None
+
 
 @dataclass
 class FileState:
@@ -152,6 +156,24 @@ def extract_file_operations(
             # Store timestamp -> (page_num, msg_id) mapping
             msg_to_page[timestamp] = (page_num, msg_id)
 
+    # First pass: collect originalFile content from tool results
+    # These are stored in the toolUseResult field of user messages
+    tool_id_to_original = {}
+    for entry in loglines:
+        tool_use_result = entry.get("toolUseResult", {})
+        if tool_use_result and "originalFile" in tool_use_result:
+            # Find the matching tool_use_id from the message content
+            message = entry.get("message", {})
+            content = message.get("content", [])
+            if isinstance(content, list):
+                for block in content:
+                    if isinstance(block, dict) and block.get("type") == "tool_result":
+                        tool_use_id = block.get("tool_use_id", "")
+                        if tool_use_id:
+                            tool_id_to_original[tool_use_id] = tool_use_result.get(
+                                "originalFile"
+                            )
+
     for entry in loglines:
         timestamp = entry.get("timestamp", "")
         message = entry.get("message", {})
@@ -199,6 +221,9 @@ def extract_file_operations(
                 replace_all = tool_input.get("replace_all", False)
 
                 if file_path and old_string is not None and new_string is not None:
+                    # Get original file content if available from tool result
+                    original_content = tool_id_to_original.get(tool_id)
+
                     operations.append(
                         FileOperation(
                             file_path=file_path,
@@ -210,6 +235,7 @@ def extract_file_operations(
                             old_string=old_string,
                             new_string=new_string,
                             replace_all=replace_all,
+                            original_content=original_content,
                         )
                     )
 
@@ -544,6 +570,11 @@ def build_file_history_repo(
                     except Exception:
                         pass
 
+                # Fallback: use original_content from tool result (for remote sessions)
+                if not fetched and op.original_content:
+                    full_path.write_text(op.original_content)
+                    fetched = True
+
                 # Commit the initial content first (no metadata = pre-session)
                 # This allows git blame to correctly attribute unchanged lines
                 if fetched:

tests/test_code_view.py

@@ -221,6 +221,165 @@ def test_no_tool_calls(self):
         operations = extract_file_operations(loglines, conversations)
         assert operations == []
 
+    def test_extracts_original_file_content_for_edit(self):
+        """Test that originalFile from toolUseResult is extracted for Edit operations.
+
+        This enables file reconstruction for remote sessions without local file access.
+        """
+        original_content = "def add(a, b):\n    return a + b\n"
+
+        loglines = [
+            # User prompt
+            {
+                "type": "user",
+                "timestamp": "2025-12-24T10:00:00.000Z",
+                "message": {"content": "Edit the file", "role": "user"},
+            },
+            # Assistant makes an Edit
+            {
+                "type": "assistant",
+                "timestamp": "2025-12-24T10:00:05.000Z",
+                "message": {
+                    "role": "assistant",
+                    "content": [
+                        {
+                            "type": "tool_use",
+                            "id": "toolu_edit_001",
+                            "name": "Edit",
+                            "input": {
+                                "file_path": "/project/math.py",
+                                "old_string": "return a + b",
+                                "new_string": "return a + b  # sum",
+                            },
+                        }
+                    ],
+                },
+            },
+            # Tool result with originalFile in toolUseResult
+            {
+                "type": "user",
+                "timestamp": "2025-12-24T10:00:10.000Z",
+                "toolUseResult": {"originalFile": original_content},
+                "message": {
+                    "role": "user",
+                    "content": [
+                        {
+                            "type": "tool_result",
+                            "tool_use_id": "toolu_edit_001",
+                            "content": "File edited successfully",
+                            "is_error": False,
+                        }
+                    ],
+                },
+            },
+        ]
+
+        conversations = [
+            {
+                "user_text": "Edit the file",
+                "timestamp": "2025-12-24T10:00:00.000Z",
+                "messages": [
+                    (
+                        "user",
+                        '{"content": "Edit the file", "role": "user"}',
+                        "2025-12-24T10:00:00.000Z",
+                    ),
+                    (
+                        "assistant",
+                        '{"content": [{"type": "tool_use", "id": "toolu_edit_001", "name": "Edit", "input": {}}], "role": "assistant"}',
+                        "2025-12-24T10:00:05.000Z",
+                    ),
+                    (
+                        "user",
+                        '{"content": [{"type": "tool_result", "tool_use_id": "toolu_edit_001"}], "role": "user"}',
+                        "2025-12-24T10:00:10.000Z",
+                    ),
+                ],
+            }
+        ]
+
+        operations = extract_file_operations(loglines, conversations)
+
+        # Should have one Edit operation
+        assert len(operations) == 1
+        op = operations[0]
+        assert op.operation_type == "edit"
+        assert op.file_path == "/project/math.py"
+        assert op.old_string == "return a + b"
+        assert op.new_string == "return a + b  # sum"
+        # original_content should be populated from toolUseResult.originalFile
+        assert op.original_content == original_content
+
+    def test_original_file_not_set_for_write(self):
+        """Test that original_content is not set for Write operations (only Edit)."""
+        loglines = [
+            {
+                "type": "user",
+                "timestamp": "2025-12-24T10:00:00.000Z",
+                "message": {"content": "Create a file", "role": "user"},
+            },
+            {
+                "type": "assistant",
+                "timestamp": "2025-12-24T10:00:05.000Z",
+                "message": {
+                    "role": "assistant",
+                    "content": [
+                        {
+                            "type": "tool_use",
+                            "id": "toolu_write_001",
+                            "name": "Write",
+                            "input": {
+                                "file_path": "/project/new.py",
+                                "content": "print('hello')\n",
+                            },
+                        }
+                    ],
+                },
+            },
+            {
+                "type": "user",
+                "timestamp": "2025-12-24T10:00:10.000Z",
+                "message": {
+                    "role": "user",
+                    "content": [
+                        {
+                            "type": "tool_result",
+                            "tool_use_id": "toolu_write_001",
+                            "content": "File written",
+                            "is_error": False,
+                        }
+                    ],
+                },
+            },
+        ]
+
+        conversations = [
+            {
+                "user_text": "Create a file",
+                "timestamp": "2025-12-24T10:00:00.000Z",
+                "messages": [
+                    (
+                        "user",
+                        '{"content": "Create a file", "role": "user"}',
+                        "2025-12-24T10:00:00.000Z",
+                    ),
+                    (
+                        "assistant",
+                        '{"content": [], "role": "assistant"}',
+                        "2025-12-24T10:00:05.000Z",
+                    ),
+                ],
+            }
+        ]
+
+        operations = extract_file_operations(loglines, conversations)
+
+        assert len(operations) == 1
+        op = operations[0]
+        assert op.operation_type == "write"
+        # Write operations don't use original_content
+        assert op.original_content is None
+
 
 class TestBuildFileTree:
     """Tests for the build_file_tree function."""