claude-code-log 0.2.4__tar.gz → 0.2.6__tar.gz

{claude_code_log-0.2.4 → claude_code_log-0.2.6}/.claude/settings.local.json

@@ -29,7 +29,8 @@
       "Bash(open /Users/dain/workspace/claude-code-log/scripts/style_guide_output/transcript_style_guide.html)",
       "Bash(open /tmp/test_preview.html)",
       "Bash(open /tmp/test_improved_preview.html)",
-      "Bash(open /tmp/test_fixed_preview.html)"
+      "Bash(open /tmp/test_fixed_preview.html)",
+      "Bash(git tag:*)"
     ],
     "deny": []
   }

claude_code_log-0.2.6/.github/workflows/docs.yml

@@ -0,0 +1,43 @@
+# Simple workflow for deploying static content to GitHub Pages
+name: Deploy static content to Pages
+
+on:
+  # Runs on pushes targeting the default branch
+  push:
+    branches: ["main"]
+
+  # Allows you to run this workflow manually from the Actions tab
+  workflow_dispatch:
+
+# Sets permissions of the GITHUB_TOKEN to allow deployment to GitHub Pages
+permissions:
+  contents: read
+  pages: write
+  id-token: write
+
+# Allow only one concurrent deployment, skipping runs queued between the run in-progress and latest queued.
+# However, do NOT cancel in-progress runs as we want to allow these production deployments to complete.
+concurrency:
+  group: "pages"
+  cancel-in-progress: false
+
+jobs:
+  # Single deploy job since we're just deploying
+  deploy:
+    environment:
+      name: github-pages
+      url: ${{ steps.deployment.outputs.page_url }}
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+      - name: Setup Pages
+        uses: actions/configure-pages@v5
+      - name: Upload artifact
+        uses: actions/upload-pages-artifact@v3
+        with:
+          # Upload docs
+          path: 'docs'
+      - name: Deploy to GitHub Pages
+        id: deployment
+        uses: actions/deploy-pages@v4

{claude_code_log-0.2.4 → claude_code_log-0.2.6}/.gitignore

@@ -177,3 +177,4 @@ cython_debug/
 test_output
 .DS_Store
 test/test_data/*.html
+.claude-trace

{claude_code_log-0.2.4 → claude_code_log-0.2.6}/CHANGELOG.md

@@ -5,11 +5,30 @@ All notable changes to claude-code-log will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+
+## [0.2.6] - 2025-06-20
+
+### Changed
+
+- **Token usage stats and usage time intervals on top level index page + make time consistently UTC**
+- **Fix example transcript link + exclude dirs from package**
+
+
+## [0.2.5] - 2025-06-18
+
+### Changed
+
+- **Tiny Justfile fixes**
+- **Create docs.yml**
+- **Improve expandable details handling + open/close all button + just render short ones + add example**
+- **Remove unnecessary line in error message**
+- **Script release process**
+
 ## [0.2.4] - 2025-06-18
 
 ### Changed
 
-- **More rrror handling**: Add better error reporting with line numbers and render fallbacks
+- **More error handling**: Add better error reporting with line numbers and render fallbacks
 
 ## [0.2.3] - 2025-06-16
 

{claude_code_log-0.2.4 → claude_code_log-0.2.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claude-code-log
-Version: 0.2.4
+Version: 0.2.6
 Summary: Convert Claude Code transcript JSONL files to HTML
 Project-URL: Homepage, https://github.com/daaain/claude-code-log
 Project-URL: Issues, https://github.com/daaain/claude-code-log/issues
@@ -29,6 +29,8 @@ A Python CLI tool that converts Claude Code transcript JSONL files into readable
 
 This tool generates clean, minimalist HTML pages showing user prompts and assistant responses chronologically. It's designed to create a readable log of your Claude Code interactions with support for both individual files and entire project hierarchies.
 
+[See example log (generated from real usage on this project).](https://daaain.github.io/claude-code-log/claude-code-log-transcript.html)
+
 ## Quickstart
 
 TL;DR: run the command below and browse the pages generated from your entire Claude Code archives:
@@ -233,7 +235,13 @@ uv run claude-code-log
 
 ## TODO
 
-- **Show top level stats on index page**: token usage added up + time of last interaction
-- **Tool Use Preview**: Show first few lines of tool use and other collapsed details
 - **In-page Filtering**: Client-side filtering and search
-- **Timeline view**: Show interaction on a timeline to get a better idea on timings and parallel calls
+- **Timeline view**: Show interaction on a timeline to get a better idea on timings and parallel calls - maybe Timeline.js optionally generated runtime?
+- document what questions does it help answering
+- filter out system message from beginning of convo to show on session navigation
+- make tool results messages be computer rather than user – or even just remove the assistant / user box around or move the tool call / result to the top?
+- integrate claude-trace request logs if present?
+- use Anthropic's own types: <https://github.com/anthropics/anthropic-sdk-python/tree/main/src/anthropic/types> – can these be used to generate Pydantic classes though?
+- Shortcut / command to resume a specific conversation by session ID $ claude --resume 550e8400-e29b-41d4-a716-446655440000?
+- Split up transcripts by jsonl files (too) as the combined ones can get quite big and add navigation to the top level
+- Localised number formatting and timezone adjustment runtime?

{claude_code_log-0.2.4 → claude_code_log-0.2.6}/README.md

@@ -10,6 +10,8 @@ A Python CLI tool that converts Claude Code transcript JSONL files into readable
 
 This tool generates clean, minimalist HTML pages showing user prompts and assistant responses chronologically. It's designed to create a readable log of your Claude Code interactions with support for both individual files and entire project hierarchies.
 
+[See example log (generated from real usage on this project).](https://daaain.github.io/claude-code-log/claude-code-log-transcript.html)
+
 ## Quickstart
 
 TL;DR: run the command below and browse the pages generated from your entire Claude Code archives:
@@ -214,7 +216,13 @@ uv run claude-code-log
 
 ## TODO
 
-- **Show top level stats on index page**: token usage added up + time of last interaction
-- **Tool Use Preview**: Show first few lines of tool use and other collapsed details
 - **In-page Filtering**: Client-side filtering and search
-- **Timeline view**: Show interaction on a timeline to get a better idea on timings and parallel calls
+- **Timeline view**: Show interaction on a timeline to get a better idea on timings and parallel calls - maybe Timeline.js optionally generated runtime?
+- document what questions does it help answering
+- filter out system message from beginning of convo to show on session navigation
+- make tool results messages be computer rather than user – or even just remove the assistant / user box around or move the tool call / result to the top?
+- integrate claude-trace request logs if present?
+- use Anthropic's own types: <https://github.com/anthropics/anthropic-sdk-python/tree/main/src/anthropic/types> – can these be used to generate Pydantic classes though?
+- Shortcut / command to resume a specific conversation by session ID $ claude --resume 550e8400-e29b-41d4-a716-446655440000?
+- Split up transcripts by jsonl files (too) as the combined ones can get quite big and add navigation to the top level
+- Localised number formatting and timezone adjustment runtime?

{claude_code_log-0.2.4 → claude_code_log-0.2.6}/claude_code_log/converter.py

@@ -97,6 +97,57 @@ def process_projects_hierarchy(
                 max(f.stat().st_mtime for f in jsonl_files) if jsonl_files else 0.0
             )
 
+            # Calculate token usage aggregation and find first/last interaction timestamps
+            total_input_tokens = 0
+            total_output_tokens = 0
+            total_cache_creation_tokens = 0
+            total_cache_read_tokens = 0
+            latest_timestamp = ""
+            earliest_timestamp = ""
+
+            # Track requestIds to avoid double-counting tokens
+            seen_request_ids: set[str] = set()
+
+            for message in messages:
+                # Track latest and earliest timestamps across all messages
+                if hasattr(message, "timestamp"):
+                    message_timestamp = getattr(message, "timestamp", "")
+                    if message_timestamp:
+                        # Track latest timestamp
+                        if not latest_timestamp or message_timestamp > latest_timestamp:
+                            latest_timestamp = message_timestamp
+
+                        # Track earliest timestamp
+                        if (
+                            not earliest_timestamp
+                            or message_timestamp < earliest_timestamp
+                        ):
+                            earliest_timestamp = message_timestamp
+
+                # Calculate token usage for assistant messages
+                if message.type == "assistant" and hasattr(message, "message"):
+                    assistant_message = getattr(message, "message")
+                    request_id = getattr(message, "requestId", None)
+
+                    if (
+                        hasattr(assistant_message, "usage")
+                        and assistant_message.usage
+                        and request_id
+                        and request_id not in seen_request_ids
+                    ):
+                        # Mark requestId as seen to avoid double-counting
+                        seen_request_ids.add(request_id)
+
+                        usage = assistant_message.usage
+                        total_input_tokens += usage.input_tokens
+                        total_output_tokens += usage.output_tokens
+                        if usage.cache_creation_input_tokens:
+                            total_cache_creation_tokens += (
+                                usage.cache_creation_input_tokens
+                            )
+                        if usage.cache_read_input_tokens:
+                            total_cache_read_tokens += usage.cache_read_input_tokens
+
             project_summaries.append(
                 {
                     "name": project_dir.name,
@@ -105,13 +156,19 @@ def process_projects_hierarchy(
                     "jsonl_count": jsonl_count,
                     "message_count": len(messages),
                     "last_modified": last_modified,
+                    "total_input_tokens": total_input_tokens,
+                    "total_output_tokens": total_output_tokens,
+                    "total_cache_creation_tokens": total_cache_creation_tokens,
+                    "total_cache_read_tokens": total_cache_read_tokens,
+                    "latest_timestamp": latest_timestamp,
+                    "earliest_timestamp": earliest_timestamp,
                 }
             )
         except Exception as e:
             print(
                 f"Warning: Failed to process {project_dir}: {e}\n"
-                f"Previous (in alphabetical order) file before error: {project_summaries[-1]}\n"
-                f"Traceback:\n{traceback.format_exc()}"
+                f"Previous (in alphabetical order) file before error: {project_summaries[-1]}"
+                f"\n{traceback.format_exc()}"
             )
             continue
 

{claude_code_log-0.2.4 → claude_code_log-0.2.6}/claude_code_log/parser.py

@@ -103,6 +103,7 @@ def load_transcript(jsonl_path: Path) -> List[TranscriptEntry]:
     messages: List[TranscriptEntry] = []
 
     with open(jsonl_path, "r", encoding="utf-8") as f:
+        print(f"Processing {jsonl_path}...")
         for line_no, line in enumerate(f):
             line = line.strip()
             if line:
@@ -149,8 +150,6 @@ def load_transcript(jsonl_path: Path) -> List[TranscriptEntry]:
                         "\n{traceback.format_exc()}"
                     )
 
-    print()
-
     return messages
 
 

{claude_code_log-0.2.4 → claude_code_log-0.2.6}/claude_code_log/renderer.py

@@ -24,9 +24,13 @@ from .parser import extract_text_content
 
 
 def format_timestamp(timestamp_str: str) -> str:
-    """Format ISO timestamp for display."""
+    """Format ISO timestamp for display, converting to UTC."""
     try:
         dt = datetime.fromisoformat(timestamp_str.replace("Z", "+00:00"))
+        # Convert to UTC if timezone-aware
+        if dt.tzinfo is not None:
+            dt = dt.utctimetuple()
+            dt = datetime(*dt[:6])  # Convert back to naive datetime in UTC
         return dt.strftime("%Y-%m-%d %H:%M:%S")
     except (ValueError, AttributeError):
         return timestamp_str
@@ -37,6 +41,41 @@ def escape_html(text: str) -> str:
     return html.escape(text)
 
 
+def create_collapsible_details(
+    summary: str, content: str, css_classes: str = ""
+) -> str:
+    """Create a collapsible details element with consistent styling and preview functionality."""
+    class_attr = ' class="collapsible-details"'
+    wrapper_classes = f"tool-content{' ' + css_classes if css_classes else ''}"
+
+    if len(content) <= 200:
+        return f"""
+        <div class="{wrapper_classes}">
+            {summary}
+            <div class="details-content">
+                {content}
+            </div>
+        </div>
+        """
+
+    # Get first ~200 characters, break at word boundaries
+    preview_text = content[:200] + "..."
+
+    return f"""
+    <div class="{wrapper_classes}">
+        <details{class_attr}>
+            <summary>
+                {summary}
+                <div class="preview-content">{preview_text}</div>
+            </summary>
+            <div class="details-content">
+                {content}
+            </div>
+        </details>
+    </div>
+    """
+
+
 def render_markdown(text: str) -> str:
     """Convert markdown text to HTML using mistune."""
     # Configure mistune with GitHub-flavored markdown features
@@ -181,17 +220,10 @@ def format_tool_use_content(tool_use: ToolUseContent) -> str:
     except (TypeError, ValueError):
         escaped_input = escape_html(str(tool_use.input))
 
-    return f"""
-    <div class="tool-content tool-use">
-        <details>
-            <summary><strong>🛠️ Tool Use:</strong> {escaped_name} (ID: {escaped_id})</summary>
-            <div class="tool-input">
-                <strong>Input:</strong>
-                <pre>{escaped_input}</pre>
-            </div>
-        </details>
-    </div>
-    """
+    summary = f"<strong>🛠️ Tool Use:</strong> {escaped_name} (ID: {escaped_id})"
+    content = f"<pre>{escaped_input}</pre>"
+
+    return create_collapsible_details(summary, content, "tool-use")
 
 
 def format_tool_result_content(tool_result: ToolResultContent) -> str:
@@ -206,37 +238,27 @@ def format_tool_result_content(tool_result: ToolResultContent) -> str:
         content_parts: List[str] = []
         for item in tool_result.content:
             if item.get("type") == "text":
-                content_parts.append(item.get("text", ""))
+                text_value = item.get("text")
+                if isinstance(text_value, str):
+                    content_parts.append(text_value)
         escaped_content = escape_html("\n".join(content_parts))
 
     error_indicator = " (🚨 Error)" if tool_result.is_error else ""
 
-    return f"""
-    <div class="tool-content tool-result">
-        <details>
-            <summary><strong>🧰 Tool Result{error_indicator}:</strong> {escaped_id}</summary>
-            <div class="tool-input">
-                <pre>{escaped_content}</pre>
-            </div>
-        </details>
-    </div>
-    """
+    summary = f"<strong>🧰 Tool Result{error_indicator}:</strong> {escaped_id}"
+    content = f"<pre>{escaped_content}</pre>"
+
+    return create_collapsible_details(summary, content, "tool-result")
 
 
 def format_thinking_content(thinking: ThinkingContent) -> str:
     """Format thinking content as HTML."""
     escaped_thinking = escape_html(thinking.thinking)
 
-    return f"""
-    <div class="tool-content thinking-content">
-        <details>
-            <summary><strong>💭 Thinking</strong></summary>
-            <div class="thinking-text">
-                <pre>{escaped_thinking}</pre>
-            </div>
-        </details>
-    </div>
-    """
+    summary = "<strong>💭 Thinking</strong>"
+    content = f'<div class="thinking-text">{escaped_thinking}</div>'
+
+    return create_collapsible_details(summary, content, "thinking-content")
 
 
 def format_image_content(image: ImageContent) -> str:
@@ -340,6 +362,14 @@ class TemplateProject:
         self.jsonl_count = project_data["jsonl_count"]
         self.message_count = project_data["message_count"]
         self.last_modified = project_data["last_modified"]
+        self.total_input_tokens = project_data.get("total_input_tokens", 0)
+        self.total_output_tokens = project_data.get("total_output_tokens", 0)
+        self.total_cache_creation_tokens = project_data.get(
+            "total_cache_creation_tokens", 0
+        )
+        self.total_cache_read_tokens = project_data.get("total_cache_read_tokens", 0)
+        self.latest_timestamp = project_data.get("latest_timestamp", "")
+        self.earliest_timestamp = project_data.get("earliest_timestamp", "")
 
         # Format display name (remove leading dash and convert dashes to slashes)
         self.display_name = self.name
@@ -348,7 +378,46 @@ class TemplateProject:
 
         # Format last modified date
         last_modified_dt = datetime.fromtimestamp(self.last_modified)
-        self.formatted_date = last_modified_dt.strftime("%Y-%m-%d %H:%M")
+        self.formatted_date = last_modified_dt.strftime("%Y-%m-%d %H:%M:%S")
+
+        # Format interaction time range
+        if self.earliest_timestamp and self.latest_timestamp:
+            if self.earliest_timestamp == self.latest_timestamp:
+                # Single interaction
+                self.formatted_time_range = format_timestamp(self.latest_timestamp)
+            else:
+                # Time range
+                earliest_formatted = format_timestamp(self.earliest_timestamp)
+                latest_formatted = format_timestamp(self.latest_timestamp)
+                self.formatted_time_range = (
+                    f"{earliest_formatted} to {latest_formatted}"
+                )
+        elif self.latest_timestamp:
+            self.formatted_time_range = format_timestamp(self.latest_timestamp)
+        else:
+            self.formatted_time_range = ""
+
+        # Format last interaction timestamp (kept for backward compatibility)
+        if self.latest_timestamp:
+            self.formatted_last_interaction = format_timestamp(self.latest_timestamp)
+        else:
+            self.formatted_last_interaction = ""
+
+        # Format token usage
+        self.token_summary = ""
+        if self.total_input_tokens > 0 or self.total_output_tokens > 0:
+            token_parts: List[str] = []
+            if self.total_input_tokens > 0:
+                token_parts.append(f"Input: {self.total_input_tokens}")
+            if self.total_output_tokens > 0:
+                token_parts.append(f"Output: {self.total_output_tokens}")
+            if self.total_cache_creation_tokens > 0:
+                token_parts.append(
+                    f"Cache Creation: {self.total_cache_creation_tokens}"
+                )
+            if self.total_cache_read_tokens > 0:
+                token_parts.append(f"Cache Read: {self.total_cache_read_tokens}")
+            self.token_summary = " | ".join(token_parts)
 
 
 class TemplateSummary:
@@ -359,6 +428,79 @@ class TemplateSummary:
         self.total_jsonl = sum(p["jsonl_count"] for p in project_summaries)
         self.total_messages = sum(p["message_count"] for p in project_summaries)
 
+        # Calculate aggregated token usage
+        self.total_input_tokens = sum(
+            p.get("total_input_tokens", 0) for p in project_summaries
+        )
+        self.total_output_tokens = sum(
+            p.get("total_output_tokens", 0) for p in project_summaries
+        )
+        self.total_cache_creation_tokens = sum(
+            p.get("total_cache_creation_tokens", 0) for p in project_summaries
+        )
+        self.total_cache_read_tokens = sum(
+            p.get("total_cache_read_tokens", 0) for p in project_summaries
+        )
+
+        # Find the most recent and earliest interaction timestamps across all projects
+        self.latest_interaction = ""
+        self.earliest_interaction = ""
+        for project in project_summaries:
+            # Check latest timestamp
+            latest_timestamp = project.get("latest_timestamp", "")
+            if latest_timestamp and (
+                not self.latest_interaction
+                or latest_timestamp > self.latest_interaction
+            ):
+                self.latest_interaction = latest_timestamp
+
+            # Check earliest timestamp
+            earliest_timestamp = project.get("earliest_timestamp", "")
+            if earliest_timestamp and (
+                not self.earliest_interaction
+                or earliest_timestamp < self.earliest_interaction
+            ):
+                self.earliest_interaction = earliest_timestamp
+
+        # Format the latest interaction timestamp
+        if self.latest_interaction:
+            self.formatted_latest_interaction = format_timestamp(
+                self.latest_interaction
+            )
+        else:
+            self.formatted_latest_interaction = ""
+
+        # Format the time range
+        if self.earliest_interaction and self.latest_interaction:
+            if self.earliest_interaction == self.latest_interaction:
+                # Single interaction
+                self.formatted_time_range = format_timestamp(self.latest_interaction)
+            else:
+                # Time range
+                earliest_formatted = format_timestamp(self.earliest_interaction)
+                latest_formatted = format_timestamp(self.latest_interaction)
+                self.formatted_time_range = (
+                    f"{earliest_formatted} to {latest_formatted}"
+                )
+        else:
+            self.formatted_time_range = ""
+
+        # Format token usage summary
+        self.token_summary = ""
+        if self.total_input_tokens > 0 or self.total_output_tokens > 0:
+            token_parts: List[str] = []
+            if self.total_input_tokens > 0:
+                token_parts.append(f"Input: {self.total_input_tokens}")
+            if self.total_output_tokens > 0:
+                token_parts.append(f"Output: {self.total_output_tokens}")
+            if self.total_cache_creation_tokens > 0:
+                token_parts.append(
+                    f"Cache Creation: {self.total_cache_creation_tokens}"
+                )
+            if self.total_cache_read_tokens > 0:
+                token_parts.append(f"Cache Read: {self.total_cache_read_tokens}")
+            self.token_summary = " | ".join(token_parts)
+
 
 def generate_html(messages: List[TranscriptEntry], title: Optional[str] = None) -> str:
     """Generate HTML from transcript messages using Jinja2 templates."""
@@ -604,9 +746,10 @@ def generate_html(messages: List[TranscriptEntry], title: Optional[str] = None)
             if command_args:
                 content_parts.append(f"<strong>Args:</strong> {escaped_command_args}")
             if command_contents:
-                content_parts.append(
-                    f"<details><summary>Content</summary><div class='content'>{escaped_command_contents}</div></details>"
+                details_html = create_collapsible_details(
+                    "Content", escaped_command_contents
                 )
+                content_parts.append(details_html)
 
             content_html = "<br>".join(content_parts)
             message_type = "system"

{claude_code_log-0.2.4 → claude_code_log-0.2.6}/claude_code_log/templates/index.html

@@ -49,6 +49,7 @@
             font-size: 1.2em;
             font-weight: 600;
             margin-bottom: 10px;
+            word-break: break-all;
         }
 
         .project-name a {
@@ -89,9 +90,9 @@
 
         .summary-stats {
             display: flex;
-            justify-content: center;
-            gap: 30px;
-            flex-wrap: wrap;
+            flex-direction: column;
+            align-items: center;
+            gap: 15px;
         }
 
         .summary-stat {
@@ -116,18 +117,32 @@
 
     <div class='summary'>
         <div class='summary-stats'>
-            <div class='summary-stat'>
-                <div class='number'>{{ summary.total_projects }}</div>
-                <div class='label'>Projects</div>
+            <div style="display: flex; gap: 3em;">
+                <div class='summary-stat'>
+                    <div class='number'>{{ summary.total_projects }}</div>
+                    <div class='label'>Projects</div>
+                </div>
+                <div class='summary-stat'>
+                    <div class='number'>{{ summary.total_jsonl }}</div>
+                    <div class='label'>Transcript Files</div>
+                </div>
+                <div class='summary-stat'>
+                    <div class='number'>{{ summary.total_messages }}</div>
+                    <div class='label'>Messages</div>
+                </div>
             </div>
+            {% if summary.token_summary %}
             <div class='summary-stat'>
-                <div class='number'>{{ summary.total_jsonl }}</div>
-                <div class='label'>Transcript Files</div>
+                <div class='number'>🪙</div>
+                <div class='label'>{{ summary.token_summary }}</div>
             </div>
+            {% endif %}
+            {% if summary.formatted_time_range %}
             <div class='summary-stat'>
-                <div class='number'>{{ summary.total_messages }}</div>
-                <div class='label'>Messages</div>
+                <div class='number'>🕐</div>
+                <div class='label'>{{ summary.formatted_time_range }}</div>
             </div>
+            {% endif %}
         </div>
     </div>
 
@@ -140,7 +155,14 @@
             <div class='project-stats'>
                 <div class='stat'>📁 {{ project.jsonl_count }} transcript files</div>
                 <div class='stat'>💬 {{ project.message_count }} messages</div>
+                {% if project.formatted_time_range %}
+                <div class='stat'>🕒 {{ project.formatted_time_range }}</div>
+                {% else %}
                 <div class='stat'>🕒 {{ project.formatted_date }}</div>
+                {% endif %}
+                {% if project.token_summary %}
+                <div class='stat'>🪙 {{ project.token_summary }}</div>
+                {% endif %}
             </div>
         </div>
         {% endfor %}