claude-code-pretty 0.1.0__tar.gz

claude_code_pretty-0.1.0/.bumpversion.cfg

@@ -0,0 +1,8 @@
+[bumpversion]
+current_version = 0.1.0
+commit = False
+tag = False
+
+[bumpversion:file:pyproject.toml]
+search = version = "{current_version}"
+replace = version = "{new_version}"

claude_code_pretty-0.1.0/.github/test-prompt.md

@@ -0,0 +1,15 @@
+You are being tested to exercise all Claude Code internal tools. Do each step below in order:
+
+1. Use Glob to list all files matching `*.sh` in the current directory
+2. Use Read to read the file `show-colors.sh`
+3. Use Write to create a file called `tmp-test-output.txt` with the content "hello from claude test"
+4. Use Edit to change "hello from claude test" to "hello from claude test - updated" in `tmp-test-output.txt`
+5. Use Grep to search for the word "color" in all `.sh` files
+6. Use Bash to run `echo "bash tool works" && date`
+7. Use the Task tool to launch a subagent with subagent_type "general-purpose" and the following prompt: "Do ALL of these steps in order: (a) Use Glob to find every file in the repo recursively with **/*. (b) Use Read to read ALL files you found - read them in parallel. (c) Use WebSearch to search for 'ANSI color codes terminal 2025 best practices'. (d) Use WebFetch to fetch https://en.wikipedia.org/wiki/ANSI_escape_code and extract the list of standard color codes. (e) Based on what you read from the repo files and the web research, use Write to create a file called 'subagent-report.md' with a detailed report that includes: a summary of what this repo does, a list of all ANSI colors currently used in claude-pretty.sh, a comparison with standard ANSI colors from your web research, and recommendations for additional colors that could improve readability. Make the report thorough."
+8. Use the Task tool to launch a subagent with subagent_type "Bash" to run: "echo '--- bash subagent test ---' && uname -a && node --version && which claude && echo '--- done ---'"
+9. Use MultiEdit on `tmp-test-output.txt` to make two changes at once: replace "hello" with "hey" and replace "updated" with "modified"
+10. Use Bash to run `echo '{"cells":[{"cell_type":"code","source":["print(1+1)"],"metadata":{},"outputs":[],"execution_count":null}],"metadata":{"kernelspec":{"display_name":"Python 3","language":"python","name":"python3"},"language_info":{"name":"python"}},"nbformat":4,"nbformat_minor":5}' > tmp-test.ipynb` to create a test notebook
+11. Use NotebookEdit on `tmp-test.ipynb` to insert a new cell with edit_mode "insert" and cell_type "code" with the source `print("notebook edit works")`
+12. Use TodoWrite to create a todo list with 3 items: "step one" (completed), "step two" (in_progress), "step three" (pending)
+13. Print a final summary saying "All tools tested successfully"

claude_code_pretty-0.1.0/.github/workflows/callable-ci.yml

@@ -0,0 +1,77 @@
+name: CI
+
+on:
+  workflow_call:
+
+jobs:
+  check:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+      - run: pip install -e ".[dev]"
+      - run: ruff check .
+      - run: ruff format --check .
+
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ["3.9", "3.10", "3.11", "3.12", "3.13"]
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+      - run: pip install -e ".[dev]"
+      - run: pytest -v
+
+  e2e:
+    strategy:
+      matrix:
+        os: [ubuntu-latest, windows-latest, macos-latest]
+    runs-on: ${{ matrix.os }}
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+      - run: pip install -e ".[dev]"
+      - run: pytest -v
+
+  live:
+    runs-on: ubuntu-latest
+    if: github.event_name == 'push' || github.event.pull_request.head.repo.full_name == github.repository
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: "20"
+
+      - run: pip install -e .
+
+      - name: Install Claude Code
+        run: npm install -g @anthropic-ai/claude-code
+
+      - name: Run claudep with test prompt
+        continue-on-error: true
+        timeout-minutes: 10
+        env:
+          CLAUDE_CODE_OAUTH_TOKEN: ${{ secrets.CLAUDE_CODE_OAUTH_TOKEN }}
+        run: |
+          claudep -p "$(cat .github/test-prompt.md)"
+
+      - name: Upload session logs
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: claude-session-logs
+          path: ~/.claude/projects/
+          retention-days: 7

claude_code_pretty-0.1.0/.github/workflows/prs.yml

@@ -0,0 +1,9 @@
+name: PRs
+
+on:
+  pull_request:
+
+jobs:
+  ci:
+    uses: ./.github/workflows/callable-ci.yml
+    secrets: inherit

claude_code_pretty-0.1.0/.github/workflows/push-to-main.yml

@@ -0,0 +1,10 @@
+name: Push to main
+
+on:
+  push:
+    branches: [main]
+
+jobs:
+  ci:
+    uses: ./.github/workflows/callable-ci.yml
+    secrets: inherit

claude_code_pretty-0.1.0/.github/workflows/release.yml

@@ -0,0 +1,59 @@
+name: Release
+
+on:
+  workflow_dispatch:
+    inputs:
+      bump:
+        description: "Version bump type"
+        required: true
+        type: choice
+        options:
+          - patch
+          - minor
+          - major
+          - initial
+
+permissions:
+  contents: write
+  id-token: write
+
+jobs:
+  release:
+    runs-on: ubuntu-latest
+    environment: pypi
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+
+      - run: pip install --upgrade pip bump2version build
+
+      - name: Configure git
+        run: |
+          git config user.name "github-actions[bot]"
+          git config user.email "github-actions[bot]@users.noreply.github.com"
+
+      - name: Bump version
+        if: inputs.bump != 'initial'
+        run: bump2version ${{ inputs.bump }}
+
+      - name: Read new version
+        id: version
+        run: echo "version=$(python3 -c "import tomllib; print(tomllib.load(open('pyproject.toml','rb'))['project']['version'])")" >> "$GITHUB_OUTPUT"
+
+      - name: Build
+        run: python -m build
+
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1
+
+      - name: Commit and tag
+        run: |
+          git add -A
+          git commit -m "chore: release v${{ steps.version.outputs.version }}" || true
+          git tag "v${{ steps.version.outputs.version }}"
+          git push origin main --tags

claude_code_pretty-0.1.0/.gitignore

@@ -0,0 +1,12 @@
+.venv/
+__pycache__/
+*.pyc
+*.egg-info/
+dist/
+build/
+.pytest_cache/
+.ruff_cache/
+*.egg
+.eggs/
+.ignore/
+tmp-*

claude_code_pretty-0.1.0/.pre-commit-config.yaml

@@ -0,0 +1,7 @@
+repos:
+  - repo: https://github.com/astral-sh/ruff-pre-commit
+    rev: v0.9.1
+    hooks:
+      - id: ruff
+        args: [--fix]
+      - id: ruff-format

claude_code_pretty-0.1.0/Makefile

@@ -0,0 +1,27 @@
+install:
+	python3 -m venv .venv
+	.venv/bin/pip install -e ".[dev]"
+	.venv/bin/pre-commit install
+
+check:
+	.venv/bin/ruff check .
+	.venv/bin/ruff format --check .
+
+format:
+	.venv/bin/ruff check --fix .
+	.venv/bin/ruff format .
+
+test:
+	.venv/bin/pytest -v
+
+test-replay:
+	.venv/bin/claudep -f tests/fixtures/sample_session.jsonl
+
+build:
+	.venv/bin/pip install hatch
+	.venv/bin/hatch build
+
+clean:
+	rm -rf .venv dist build *.egg-info src/*.egg-info
+
+.PHONY: install check format test test-replay build clean

claude_code_pretty-0.1.0/PKG-INFO

@@ -0,0 +1,90 @@
+Metadata-Version: 2.4
+Name: claude-code-pretty
+Version: 0.1.0
+Summary: Pretty formatter for Claude Code stream-json output
+Project-URL: Homepage, https://github.com/lucasvtiradentes/claude-code-pretty
+Project-URL: Repository, https://github.com/lucasvtiradentes/claude-code-pretty
+Project-URL: Issues, https://github.com/lucasvtiradentes/claude-code-pretty/issues
+Author: lucasvtiradentes
+License-Expression: MIT
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Software Development
+Requires-Python: >=3.9
+Provides-Extra: dev
+Requires-Dist: pre-commit>=4; extra == 'dev'
+Requires-Dist: pytest>=7; extra == 'dev'
+Requires-Dist: ruff>=0.9; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# claude-code-pretty
+
+Pretty formatter for Claude Code - stream sessions in real-time or replay saved .jsonl files.
+
+<div align="center">
+   <img src=".github/images/demo.png" width="70%">
+</div>
+
+## Features
+
+- stream mode    - run claude with pretty output in real-time
+- replay mode    - replay saved .jsonl session files
+- tool display   - formatted output for Glob, Grep, Bash, Read, Edit, etc.
+- markdown       - renders **bold** and `code` with ANSI styles
+- subagent depth - visual indentation for nested Task calls
+- cost tracking  - shows duration, cost, tokens per session
+
+## Installation
+
+```bash
+pip install claude-code-pretty
+```
+
+Aliases: `claudep`, `ccp`, `claude-code-pretty`
+
+## Usage
+
+```bash
+# stream mode - run claude with pretty output
+claudep -p "explain this code"
+
+# replay mode - replay a saved session
+claudep -f ~/.claude/projects/.../session.jsonl
+```
+
+Stream mode runs claude with these flags automatically:
+```
+--print --verbose --dangerously-skip-permissions --output-format stream-json --include-partial-messages
+```
+
+## Environment
+
+| Variable                 | Default | Description                         |
+|--------------------------|---------|-------------------------------------|
+| CP_TOOL_RESULT_MAX_CHARS | 300     | Max chars for tool results (0=hide) |
+| CP_READ_PREVIEW_LINES    | 5       | Lines to preview from Read (0=hide) |
+
+## Development
+
+```bash
+make install      # setup venv + install
+make test         # run pytest
+make check        # ruff lint
+
+# dev alias
+ln -sf $(pwd)/.venv/bin/claudep ~/.local/bin/claudepd
+```
+
+## License
+
+MIT

claude_code_pretty-0.1.0/README.md

@@ -0,0 +1,61 @@
+# claude-code-pretty
+
+Pretty formatter for Claude Code - stream sessions in real-time or replay saved .jsonl files.
+
+<div align="center">
+   <img src=".github/images/demo.png" width="70%">
+</div>
+
+## Features
+
+- stream mode    - run claude with pretty output in real-time
+- replay mode    - replay saved .jsonl session files
+- tool display   - formatted output for Glob, Grep, Bash, Read, Edit, etc.
+- markdown       - renders **bold** and `code` with ANSI styles
+- subagent depth - visual indentation for nested Task calls
+- cost tracking  - shows duration, cost, tokens per session
+
+## Installation
+
+```bash
+pip install claude-code-pretty
+```
+
+Aliases: `claudep`, `ccp`, `claude-code-pretty`
+
+## Usage
+
+```bash
+# stream mode - run claude with pretty output
+claudep -p "explain this code"
+
+# replay mode - replay a saved session
+claudep -f ~/.claude/projects/.../session.jsonl
+```
+
+Stream mode runs claude with these flags automatically:
+```
+--print --verbose --dangerously-skip-permissions --output-format stream-json --include-partial-messages
+```
+
+## Environment
+
+| Variable                 | Default | Description                         |
+|--------------------------|---------|-------------------------------------|
+| CP_TOOL_RESULT_MAX_CHARS | 300     | Max chars for tool results (0=hide) |
+| CP_READ_PREVIEW_LINES    | 5       | Lines to preview from Read (0=hide) |
+
+## Development
+
+```bash
+make install      # setup venv + install
+make test         # run pytest
+make check        # ruff lint
+
+# dev alias
+ln -sf $(pwd)/.venv/bin/claudep ~/.local/bin/claudepd
+```
+
+## License
+
+MIT

claude_code_pretty-0.1.0/pyproject.toml

@@ -0,0 +1,55 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "claude-code-pretty"
+version = "0.1.0"
+description = "Pretty formatter for Claude Code stream-json output"
+readme = "README.md"
+requires-python = ">=3.9"
+license = "MIT"
+authors = [{ name = "lucasvtiradentes" }]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Environment :: Console",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+    "Topic :: Software Development",
+]
+
+[project.urls]
+Homepage = "https://github.com/lucasvtiradentes/claude-code-pretty"
+Repository = "https://github.com/lucasvtiradentes/claude-code-pretty"
+Issues = "https://github.com/lucasvtiradentes/claude-code-pretty/issues"
+
+[project.optional-dependencies]
+dev = ["pytest>=7", "ruff>=0.9", "pre-commit>=4"]
+
+[project.scripts]
+claudep = "claudecodepretty.cli:main"
+ccp = "claudecodepretty.cli:main"
+claude-code-pretty = "claudecodepretty.cli:main"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/claudecodepretty"]
+
+[tool.hatch.build.targets.wheel.sources]
+"src" = ""
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+
+[tool.ruff]
+line-length = 120
+
+[tool.ruff.lint]
+select = ["E", "F", "I"]

claude_code_pretty-0.1.0/src/claudecodepretty/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

claude_code_pretty-0.1.0/src/claudecodepretty/cli.py

@@ -0,0 +1,54 @@
+import sys
+
+from claudecodepretty import __version__
+from claudecodepretty.constants import CLI_NAME
+from claudecodepretty.modes import run_replay, run_stream
+
+
+def print_help():
+    print(f"""{CLI_NAME} - Pretty formatter for Claude Code stream-json output
+
+Usage:
+  {CLI_NAME} [OPTIONS] [CLAUDE_ARGS...]
+  {CLI_NAME} -f <session.jsonl>
+
+Options:
+  -f, --file FILE    Replay a saved session .jsonl file
+  -h, --help         Show this help
+  -v, --version      Show version
+
+Environment:
+  CP_TOOL_RESULT_MAX_CHARS   Max chars for tool results (default: 300, 0=hide)
+  CP_READ_PREVIEW_LINES      Lines to preview from Read (default: 5, 0=hide)
+
+Examples:
+  {CLI_NAME} -p "explain this code"
+  {CLI_NAME} -f ~/.claude/projects/.../session.jsonl
+  cat session.jsonl | {CLI_NAME} -f -""")
+
+
+def main():
+    args = sys.argv[1:]
+
+    if not args or "-h" in args or "--help" in args:
+        print_help()
+        sys.exit(0)
+
+    if "-v" in args or "--version" in args:
+        print(__version__)
+        sys.exit(0)
+
+    if "-f" in args or "--file" in args:
+        try:
+            idx = args.index("-f") if "-f" in args else args.index("--file")
+            file_path = args[idx + 1]
+            sys.exit(run_replay(file_path))
+        except IndexError:
+            print("Error: -f requires a file path")
+            sys.exit(1)
+
+    sys.exit(run_stream(args))
+
+
+if __name__ == "__main__":
+    main()

claude_code_pretty-0.1.0/src/claudecodepretty/colors.py

@@ -0,0 +1,56 @@
+BOLD = "\033[1m"
+INVERSE = "\033[7m"
+GREEN = "\033[32m"
+ORANGE = "\033[33m"
+PURPLE = "\033[35m"
+CYAN = "\033[36m"
+BLUE = "\033[34m"
+YELLOW = "\033[93m"
+DIM = "\033[90m"
+RED = "\033[31m"
+RESET = "\033[0m"
+
+
+def green(text: str) -> str:
+    return f"{GREEN}{text}{RESET}"
+
+
+def orange(text: str) -> str:
+    return f"{ORANGE}{text}{RESET}"
+
+
+def purple(text: str) -> str:
+    return f"{PURPLE}{text}{RESET}"
+
+
+def cyan(text: str) -> str:
+    return f"{CYAN}{text}{RESET}"
+
+
+def blue(text: str) -> str:
+    return f"{BLUE}{text}{RESET}"
+
+
+def yellow(text: str) -> str:
+    return f"{YELLOW}{text}{RESET}"
+
+
+def dim(text: str) -> str:
+    return f"{DIM}{text}{RESET}"
+
+
+def red(text: str) -> str:
+    return f"{RED}{text}{RESET}"
+
+
+def bold(text: str) -> str:
+    return f"{BOLD}{text}{RESET}"
+
+
+def render_markdown(text: str) -> str:
+    import re
+
+    text = re.sub(r"\*\*(.+?)\*\*", rf"{BOLD}\1{RESET}", text)
+    text = re.sub(r"__(.+?)__", rf"{BOLD}\1{RESET}", text)
+    text = re.sub(r"`([^`]+)`", rf"{INVERSE}\1{RESET}", text)
+    return text

claude_code_pretty-0.1.0/src/claudecodepretty/constants.py

@@ -0,0 +1,9 @@
+import os
+
+CLI_NAME = "claudep"
+DIST_NAME = "claude-code-pretty"
+INDENT = "   "
+HIDE_TOOLS = {"Write", "TodoWrite", "Read", "Glob", "Grep", "Bash", "Task", "Edit", "MultiEdit", "NotebookEdit"}
+
+TOOL_RESULT_MAX_CHARS = int(os.environ.get("CP_TOOL_RESULT_MAX_CHARS", "300"))
+READ_PREVIEW_LINES = int(os.environ.get("CP_READ_PREVIEW_LINES", "5"))

claude_code_pretty-0.1.0/src/claudecodepretty/handlers/__init__.py

@@ -0,0 +1,16 @@
+from claudecodepretty.handlers.assistant import handle_assistant_message
+from claudecodepretty.handlers.base import ParseResult, ParserState
+from claudecodepretty.handlers.result import handle_result
+from claudecodepretty.handlers.stream import handle_stream_event
+from claudecodepretty.handlers.system import handle_system
+from claudecodepretty.handlers.user import handle_user_message
+
+__all__ = [
+    "ParseResult",
+    "ParserState",
+    "handle_system",
+    "handle_stream_event",
+    "handle_user_message",
+    "handle_assistant_message",
+    "handle_result",
+]

claude_code_pretty-0.1.0/src/claudecodepretty/handlers/assistant.py

@@ -0,0 +1,24 @@
+from claudecodepretty.colors import render_markdown
+from claudecodepretty.handlers.base import ParseResult, ParserState
+from claudecodepretty.handlers.tools import dispatch_tool
+
+
+def handle_assistant_message(data: dict, state: ParserState, result: ParseResult):
+    message = data.get("message", {})
+    content = message.get("content", [])
+
+    if not isinstance(content, list):
+        return
+
+    if state.mode == "replay":
+        for block in content:
+            if block.get("type") == "text":
+                result.add(render_markdown(block.get("text", "")))
+
+    for block in content:
+        if block.get("type") != "tool_use":
+            continue
+
+        name = block.get("name", "")
+        inp = block.get("input", {})
+        dispatch_tool(name, inp, state, result)

claude_code_pretty-0.1.0/src/claudecodepretty/handlers/base.py

@@ -0,0 +1,81 @@
+from dataclasses import dataclass, field
+
+from claudecodepretty.colors import BOLD, DIM, INVERSE, RESET
+
+
+@dataclass
+class ParserState:
+    mode: str = "stream"
+    current_tool: str = ""
+    subagent_depth: int = 0
+    sp: str = ""
+    in_bold: bool = False
+    in_code: bool = False
+    pending_char: str = ""
+
+    def update_sp(self):
+        self.sp = "".join(f"{DIM}│{RESET} " for _ in range(self.subagent_depth))
+
+    def increment_depth(self):
+        self.subagent_depth += 1
+        self.update_sp()
+
+    def decrement_depth(self):
+        if self.subagent_depth > 0:
+            self.subagent_depth -= 1
+            self.update_sp()
+
+    def _get_style(self) -> str:
+        if self.in_bold and self.in_code:
+            return BOLD + INVERSE
+        if self.in_bold:
+            return BOLD
+        if self.in_code:
+            return INVERSE
+        return ""
+
+    def render_text(self, text: str) -> str:
+        out = []
+        i = 0
+        buf = self.pending_char + text
+        self.pending_char = ""
+
+        while i < len(buf):
+            ch = buf[i]
+            if ch == "*" and not self.in_code:
+                if i + 1 < len(buf):
+                    if buf[i + 1] == "*":
+                        self.in_bold = not self.in_bold
+                        out.append(RESET + self._get_style())
+                        i += 2
+                        continue
+                    else:
+                        out.append(ch)
+                        i += 1
+                else:
+                    self.pending_char = "*"
+                    break
+            elif ch == "`":
+                self.in_code = not self.in_code
+                out.append(RESET + self._get_style())
+                i += 1
+            else:
+                out.append(ch)
+                i += 1
+
+        return "".join(out)
+
+
+@dataclass
+class ParseResult:
+    output: str = ""
+    messages: list[str] = field(default_factory=list)
+
+    def add(self, text: str):
+        self.messages.append(text)
+
+    def add_inline(self, text: str):
+        self.messages.append(text)
+
+    def get_output(self) -> str:
+        return "".join(self.messages)

claude_code_pretty-0.1.0/src/claudecodepretty/handlers/result.py

@@ -0,0 +1,27 @@
+from claudecodepretty.colors import DIM, RED, RESET
+from claudecodepretty.handlers.base import ParseResult, ParserState
+
+
+def handle_result(data: dict, state: ParserState, result: ParseResult):
+    while state.subagent_depth > 0:
+        result.add(f"{state.sp}{DIM}└───────────────────────────────{RESET}\n")
+        state.decrement_depth()
+
+    if data.get("is_error"):
+        result.add(f"\n{RED}[error] {data.get('result', 'unknown error')}{RESET}\n")
+    else:
+        duration_ms = data.get("duration_ms", 0)
+        duration = f"{duration_ms / 1000:.1f}"
+        cost = f"{data.get('total_cost_usd', 0):.4f}"
+        turns = data.get("num_turns", 0)
+        usage = data.get("usage", {})
+        input_tokens = sum(
+            [
+                usage.get("input_tokens", 0),
+                usage.get("cache_read_input_tokens", 0),
+                usage.get("cache_creation_input_tokens", 0),
+            ]
+        )
+        output_tokens = usage.get("output_tokens", 0)
+        stats = f"{duration}s, ${cost}, {turns} turns, {input_tokens} in / {output_tokens} out"
+        result.add(f"\n{DIM}[done] {stats}{RESET}\n")

claude_code_pretty-0.1.0/src/claudecodepretty/handlers/stream.py

@@ -0,0 +1,39 @@
+from claudecodepretty.colors import DIM, PURPLE, RED, RESET
+from claudecodepretty.constants import HIDE_TOOLS
+from claudecodepretty.handlers.base import ParseResult, ParserState
+
+
+def handle_stream_event(data: dict, state: ParserState, result: ParseResult):
+    event = data.get("event", {})
+    event_type = event.get("type", "")
+
+    if event_type == "content_block_start":
+        if state.subagent_depth > 0:
+            result.add(f"{state.sp}{DIM}└───────────────────────────────{RESET}\n")
+            state.decrement_depth()
+
+        block = event.get("content_block", {})
+        if block.get("type") == "tool_use":
+            name = block.get("name", "")
+            state.current_tool = name
+            if name not in HIDE_TOOLS:
+                result.add(f"\n{state.sp}{PURPLE}[{name}] ")
+
+    elif event_type == "content_block_delta":
+        delta = event.get("delta", {})
+        delta_type = delta.get("type", "")
+
+        if delta_type == "text_delta":
+            result.add_inline(state.render_text(delta.get("text", "")))
+        elif delta_type == "input_json_delta":
+            if state.current_tool not in HIDE_TOOLS:
+                result.add_inline(delta.get("partial_json", ""))
+
+    elif event_type == "content_block_stop":
+        if state.current_tool not in HIDE_TOOLS:
+            result.add(f"{RESET}\n")
+        state.current_tool = ""
+
+    elif event_type == "error":
+        error = event.get("error", str(event))
+        result.add(f"\n{state.sp}{RED}[error] {error}{RESET}\n")

claude_code_pretty-0.1.0/src/claudecodepretty/handlers/system.py

@@ -0,0 +1,16 @@
+from claudecodepretty.colors import DIM, RESET
+from claudecodepretty.constants import INDENT
+from claudecodepretty.handlers.base import ParseResult, ParserState
+
+
+def handle_system(data: dict, state: ParserState, result: ParseResult):
+    if data.get("subtype") == "init":
+        session_id = data.get("session_id", "")
+        cwd = data.get("cwd", "").replace("/", "-").replace("_", "-")
+        model = data.get("model", "")
+        model_name = model.split("-")[1] if "-" in model else model
+
+        result.add(f"{DIM}[session]\n")
+        result.add(f"{INDENT}id:    {session_id}\n")
+        result.add(f"{INDENT}path:  ~/.claude/projects/{cwd}/{session_id}.jsonl\n")
+        result.add(f"{INDENT}model: {model_name}{RESET}\n\n")

claude_code_pretty-0.1.0/src/claudecodepretty/handlers/tools/__init__.py

@@ -0,0 +1,31 @@
+from claudecodepretty.handlers.base import ParseResult, ParserState
+from claudecodepretty.handlers.tools.bash import handle_bash
+from claudecodepretty.handlers.tools.edit import handle_edit
+from claudecodepretty.handlers.tools.glob import handle_glob
+from claudecodepretty.handlers.tools.grep import handle_grep
+from claudecodepretty.handlers.tools.notebook import handle_notebook
+from claudecodepretty.handlers.tools.read import handle_read
+from claudecodepretty.handlers.tools.task import handle_task
+from claudecodepretty.handlers.tools.todo import handle_todo
+from claudecodepretty.handlers.tools.write import handle_write
+
+
+def dispatch_tool(name: str, inp: dict, state: ParserState, result: ParseResult):
+    if name == "TodoWrite":
+        handle_todo(inp, state, result)
+    elif name == "Write":
+        handle_write(inp, state, result)
+    elif name == "Read":
+        handle_read(inp, state, result)
+    elif name == "Glob":
+        handle_glob(inp, state, result)
+    elif name == "Grep":
+        handle_grep(inp, state, result)
+    elif name in ("Edit", "MultiEdit"):
+        handle_edit(name, inp, state, result)
+    elif name == "NotebookEdit":
+        handle_notebook(inp, state, result)
+    elif name == "Bash":
+        handle_bash(inp, state, result)
+    elif name == "Task":
+        handle_task(inp, state, result)

claude_code_pretty-0.1.0/src/claudecodepretty/handlers/tools/bash.py

@@ -0,0 +1,6 @@
+from claudecodepretty.colors import PURPLE, RESET
+from claudecodepretty.handlers.base import ParseResult, ParserState
+
+
+def handle_bash(inp: dict, state: ParserState, result: ParseResult):
+    result.add(f"\n{state.sp}{PURPLE}[Bash] {inp.get('command', '')}{RESET}\n")

claude_code_pretty-0.1.0/src/claudecodepretty/handlers/tools/edit.py

@@ -0,0 +1,6 @@
+from claudecodepretty.colors import ORANGE, RESET
+from claudecodepretty.handlers.base import ParseResult, ParserState
+
+
+def handle_edit(name: str, inp: dict, state: ParserState, result: ParseResult):
+    result.add(f"\n{state.sp}{ORANGE}[{name}] {inp.get('file_path', '')}{RESET}\n")

claude_code_pretty-0.1.0/src/claudecodepretty/handlers/tools/glob.py

@@ -0,0 +1,6 @@
+from claudecodepretty.colors import PURPLE, RESET
+from claudecodepretty.handlers.base import ParseResult, ParserState
+
+
+def handle_glob(inp: dict, state: ParserState, result: ParseResult):
+    result.add(f"\n{state.sp}{PURPLE}[Glob] {inp.get('pattern', '')}{RESET}\n")

claude_code_pretty-0.1.0/src/claudecodepretty/handlers/tools/grep.py

@@ -0,0 +1,12 @@
+from claudecodepretty.colors import PURPLE, RESET
+from claudecodepretty.handlers.base import ParseResult, ParserState
+
+
+def handle_grep(inp: dict, state: ParserState, result: ParseResult):
+    pattern = inp.get("pattern", "")
+    path = inp.get("path", "")
+    if path:
+        path = path.split("/")[-1]
+        result.add(f'\n{state.sp}{PURPLE}[Grep] "{pattern}" in {path}{RESET}\n')
+    else:
+        result.add(f'\n{state.sp}{PURPLE}[Grep] "{pattern}"{RESET}\n')

claude_code_pretty-0.1.0/src/claudecodepretty/handlers/tools/notebook.py

@@ -0,0 +1,6 @@
+from claudecodepretty.colors import ORANGE, RESET
+from claudecodepretty.handlers.base import ParseResult, ParserState
+
+
+def handle_notebook(inp: dict, state: ParserState, result: ParseResult):
+    result.add(f"\n{state.sp}{ORANGE}[NotebookEdit] {inp.get('notebook_path', '')}{RESET}\n")

claude_code_pretty-0.1.0/src/claudecodepretty/handlers/tools/read.py

@@ -0,0 +1,6 @@
+from claudecodepretty.colors import GREEN, RESET
+from claudecodepretty.handlers.base import ParseResult, ParserState
+
+
+def handle_read(inp: dict, state: ParserState, result: ParseResult):
+    result.add(f"\n{state.sp}{GREEN}[Read] {inp.get('file_path', '')}{RESET}\n")

claude_code_pretty-0.1.0/src/claudecodepretty/handlers/tools/task.py

@@ -0,0 +1,11 @@
+from claudecodepretty.colors import BLUE, DIM, RESET
+from claudecodepretty.handlers.base import ParseResult, ParserState
+
+
+def handle_task(inp: dict, state: ParserState, result: ParseResult):
+    prompt = inp.get("prompt", inp.get("description", ""))[:50]
+    model = inp.get("model", "sonnet")
+    result.add(f'\n{state.sp}{BLUE}[Task] "{prompt}" ({model}){RESET}\n')
+    if state.mode == "stream":
+        state.increment_depth()
+        result.add(f"{state.sp}{DIM}┌───────────────────────────────{RESET}\n")

claude_code_pretty-0.1.0/src/claudecodepretty/handlers/tools/todo.py

@@ -0,0 +1,18 @@
+from claudecodepretty.colors import DIM, GREEN, ORANGE, RESET, YELLOW
+from claudecodepretty.constants import INDENT
+from claudecodepretty.handlers.base import ParseResult, ParserState
+
+
+def handle_todo(inp: dict, state: ParserState, result: ParseResult):
+    result.add(f"\n{state.sp}{YELLOW}[Todo]{RESET}\n")
+    for todo in inp.get("todos", []):
+        status = todo.get("status", "pending")
+        text = todo.get("content", "")
+        if status == "completed":
+            mark = f"{GREEN}[x]{RESET}"
+        elif status == "in_progress":
+            mark = f"{ORANGE}[~]{RESET}"
+        else:
+            mark = f"{DIM}[ ]{RESET}"
+        result.add(f"{state.sp}{INDENT}{mark} {text}\n")
+    result.add("\n")

claude_code_pretty-0.1.0/src/claudecodepretty/handlers/tools/write.py

@@ -0,0 +1,6 @@
+from claudecodepretty.colors import ORANGE, RESET
+from claudecodepretty.handlers.base import ParseResult, ParserState
+
+
+def handle_write(inp: dict, state: ParserState, result: ParseResult):
+    result.add(f"\n{state.sp}{ORANGE}[Write] {inp.get('file_path', '')}{RESET}\n")

claude_code_pretty-0.1.0/src/claudecodepretty/handlers/user.py

@@ -0,0 +1,51 @@
+import re
+
+from claudecodepretty.colors import DIM, GREEN, RED, RESET
+from claudecodepretty.constants import INDENT, READ_PREVIEW_LINES, TOOL_RESULT_MAX_CHARS
+from claudecodepretty.handlers.base import ParseResult, ParserState
+
+
+def handle_user_message(data: dict, state: ParserState, result: ParseResult):
+    message = data.get("message", {})
+    content = message.get("content", "")
+
+    if isinstance(content, str):
+        if state.mode == "replay":
+            text = content[:200]
+            result.add(f"\n{GREEN}[user]{RESET} {text}")
+            if len(content) > 200:
+                result.add(f"{DIM}...{RESET}")
+            result.add("\n")
+        return
+
+    if not isinstance(content, list) or not content:
+        return
+
+    first = content[0]
+    content_type = first.get("type", "")
+
+    if content_type == "tool_result":
+        tool_content = first.get("content", "")
+
+        if isinstance(tool_content, str):
+            if tool_content.startswith(("Todos have been", "The file")) and "has been" in tool_content:
+                return
+            if "<tool_use_error>" in tool_content:
+                error_msg = re.sub(r"<[^>]*>", "", tool_content)
+                result.add(f"{state.sp}{RED}{INDENT}✗ {error_msg}{RESET}\n\n")
+                return
+
+            if "\n" in tool_content:
+                if READ_PREVIEW_LINES == 0:
+                    return
+                lines = tool_content.split("\n")[:READ_PREVIEW_LINES]
+                for line in lines:
+                    result.add(f"{state.sp}{DIM}{INDENT}→ {line}{RESET}\n")
+                if len(tool_content.split("\n")) > READ_PREVIEW_LINES:
+                    result.add(f"{state.sp}{INDENT}...\n")
+                result.add("\n")
+            else:
+                if TOOL_RESULT_MAX_CHARS == 0:
+                    return
+                text = tool_content if TOOL_RESULT_MAX_CHARS < 0 else tool_content[:TOOL_RESULT_MAX_CHARS]
+                result.add(f"{state.sp}{DIM}{INDENT}→ {text}{RESET}\n\n")

claude_code_pretty-0.1.0/src/claudecodepretty/modes/__init__.py

@@ -0,0 +1,4 @@
+from claudecodepretty.modes.replay import run_replay
+from claudecodepretty.modes.stream import run_stream
+
+__all__ = ["run_stream", "run_replay"]

claude_code_pretty-0.1.0/src/claudecodepretty/modes/replay.py

@@ -0,0 +1,34 @@
+import os
+import sys
+
+from claudecodepretty.colors import DIM, RESET
+from claudecodepretty.handlers import ParserState
+from claudecodepretty.parser import parse_json_line
+
+
+def run_replay(file_path: str) -> int:
+    state = ParserState(mode="replay")
+
+    if file_path == "-":
+        source = sys.stdin
+        print(f"{DIM}[replay] stdin{RESET}\n")
+    else:
+        if not os.path.exists(file_path):
+            print(f"Error: File not found: {file_path}")
+            return 1
+        source = open(file_path, "r")
+        print(f"{DIM}[replay] {file_path}{RESET}\n")
+
+    try:
+        for line in source:
+            line = line.strip()
+            if line:
+                result = parse_json_line(line, state)
+                output = result.get_output()
+                if output:
+                    print(output, end="", flush=True)
+    finally:
+        if file_path != "-":
+            source.close()
+
+    return 0

claude_code_pretty-0.1.0/src/claudecodepretty/modes/stream.py

@@ -0,0 +1,44 @@
+import subprocess
+import sys
+
+from claudecodepretty.handlers import ParserState
+from claudecodepretty.parser import parse_json_line
+
+
+def run_stream(args: list[str]) -> int:
+    cmd = [
+        "claude",
+        "--print",
+        "--verbose",
+        "--dangerously-skip-permissions",
+        "--output-format",
+        "stream-json",
+        "--include-partial-messages",
+        *args,
+    ]
+
+    state = ParserState(mode="stream")
+
+    process = subprocess.Popen(
+        cmd,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.STDOUT,
+        text=True,
+        bufsize=1,
+    )
+
+    try:
+        for line in process.stdout:
+            line = line.strip()
+            if line:
+                result = parse_json_line(line, state)
+                output = result.get_output()
+                if output:
+                    print(output, end="", flush=True)
+    except KeyboardInterrupt:
+        process.terminate()
+        sys.exit(130)
+    finally:
+        process.wait()
+
+    return process.returncode

claude_code_pretty-0.1.0/src/claudecodepretty/parser.py

@@ -0,0 +1,40 @@
+import json
+
+from claudecodepretty.colors import RED, RESET
+from claudecodepretty.handlers import (
+    ParseResult,
+    ParserState,
+    handle_assistant_message,
+    handle_result,
+    handle_stream_event,
+    handle_system,
+    handle_user_message,
+)
+
+__all__ = ["parse_json_line", "ParserState", "ParseResult"]
+
+
+def parse_json_line(line: str, state: ParserState) -> ParseResult:
+    result = ParseResult()
+
+    try:
+        data = json.loads(line)
+    except json.JSONDecodeError:
+        return result
+
+    msg_type = data.get("type", "")
+
+    if msg_type == "system":
+        handle_system(data, state, result)
+    elif msg_type == "stream_event":
+        handle_stream_event(data, state, result)
+    elif msg_type == "user":
+        handle_user_message(data, state, result)
+    elif msg_type == "assistant":
+        handle_assistant_message(data, state, result)
+    elif msg_type == "result":
+        handle_result(data, state, result)
+    elif msg_type == "error":
+        result.add(f"\n{state.sp}{RED}[error] {data.get('error', 'unknown error')}{RESET}")
+
+    return result

claude_code_pretty-0.1.0/tests/fixtures/sample_session.jsonl

@@ -0,0 +1,7 @@
+{"type":"system","subtype":"init","session_id":"test-session-123","cwd":"/Users/test/project","model":"claude-sonnet-4-20250514"}
+{"type":"user","message":{"content":"List all Python files"}}
+{"type":"assistant","message":{"content":[{"type":"text","text":"I'll list all Python files for you."}]}}
+{"type":"assistant","message":{"content":[{"type":"tool_use","name":"Glob","input":{"pattern":"*.py"}}]}}
+{"type":"user","message":{"content":[{"type":"tool_result","content":"main.py\nutils.py\ntest.py"}]}}
+{"type":"assistant","message":{"content":[{"type":"text","text":"Found 3 Python files: main.py, utils.py, and test.py."}]}}
+{"type":"result","is_error":false,"duration_ms":2500,"total_cost_usd":0.025,"num_turns":2,"usage":{"input_tokens":500,"output_tokens":100}}

claude_code_pretty-0.1.0/tests/test_parser.py

@@ -0,0 +1,180 @@
+import json
+
+from claudecodepretty.parser import ParserState, parse_json_line
+
+
+def test_parse_system_init():
+    state = ParserState(mode="stream")
+    line = json.dumps(
+        {
+            "type": "system",
+            "subtype": "init",
+            "session_id": "abc-123",
+            "cwd": "/Users/test/project",
+            "model": "claude-sonnet-4-20250514",
+        }
+    )
+    result = parse_json_line(line, state)
+    output = result.get_output()
+
+    assert "[session]" in output
+    assert "abc-123" in output
+    assert "sonnet" in output
+
+
+def test_parse_tool_use_glob():
+    state = ParserState(mode="stream")
+    line = json.dumps(
+        {
+            "type": "assistant",
+            "message": {
+                "content": [
+                    {
+                        "type": "tool_use",
+                        "name": "Glob",
+                        "input": {"pattern": "*.py"},
+                    }
+                ]
+            },
+        }
+    )
+    result = parse_json_line(line, state)
+    output = result.get_output()
+
+    assert "[Glob]" in output
+    assert "*.py" in output
+
+
+def test_parse_tool_use_bash():
+    state = ParserState(mode="stream")
+    line = json.dumps(
+        {
+            "type": "assistant",
+            "message": {
+                "content": [
+                    {
+                        "type": "tool_use",
+                        "name": "Bash",
+                        "input": {"command": "echo hello"},
+                    }
+                ]
+            },
+        }
+    )
+    result = parse_json_line(line, state)
+    output = result.get_output()
+
+    assert "[Bash]" in output
+    assert "echo hello" in output
+
+
+def test_parse_todo_write():
+    state = ParserState(mode="stream")
+    line = json.dumps(
+        {
+            "type": "assistant",
+            "message": {
+                "content": [
+                    {
+                        "type": "tool_use",
+                        "name": "TodoWrite",
+                        "input": {
+                            "todos": [
+                                {"status": "completed", "content": "item one"},
+                                {"status": "in_progress", "content": "item two"},
+                                {"status": "pending", "content": "item three"},
+                            ]
+                        },
+                    }
+                ]
+            },
+        }
+    )
+    result = parse_json_line(line, state)
+    output = result.get_output()
+
+    assert "[Todo]" in output
+    assert "item one" in output
+    assert "item two" in output
+    assert "item three" in output
+
+
+def test_parse_result():
+    state = ParserState(mode="stream")
+    line = json.dumps(
+        {
+            "type": "result",
+            "is_error": False,
+            "duration_ms": 5000,
+            "total_cost_usd": 0.05,
+            "num_turns": 3,
+            "usage": {
+                "input_tokens": 1000,
+                "output_tokens": 500,
+            },
+        }
+    )
+    result = parse_json_line(line, state)
+    output = result.get_output()
+
+    assert "[done]" in output
+    assert "5.0s" in output
+    assert "$0.0500" in output
+    assert "3 turns" in output
+
+
+def test_parse_task_increments_depth():
+    state = ParserState(mode="stream")
+    line = json.dumps(
+        {
+            "type": "assistant",
+            "message": {
+                "content": [
+                    {
+                        "type": "tool_use",
+                        "name": "Task",
+                        "input": {"prompt": "do something", "model": "sonnet"},
+                    }
+                ]
+            },
+        }
+    )
+    parse_json_line(line, state)
+
+    assert state.subagent_depth == 1
+    assert "│" in state.sp
+
+
+def test_replay_mode_shows_user_prompt():
+    state = ParserState(mode="replay")
+    line = json.dumps(
+        {
+            "type": "user",
+            "message": {
+                "content": "Hello, can you help me?",
+            },
+        }
+    )
+    result = parse_json_line(line, state)
+    output = result.get_output()
+
+    assert "[user]" in output
+    assert "Hello" in output
+
+
+def test_replay_mode_shows_assistant_text():
+    state = ParserState(mode="replay")
+    line = json.dumps(
+        {
+            "type": "assistant",
+            "message": {
+                "content": [
+                    {"type": "text", "text": "Sure, I can help!"},
+                ],
+            },
+        }
+    )
+    result = parse_json_line(line, state)
+    output = result.get_output()
+
+    assert "Sure, I can help!" in output