cc-context-stats 1.3.0

package/src/claude_statusline/graphs/renderer.py

@@ -0,0 +1,346 @@
+"""ASCII graph rendering engine."""
+
+from __future__ import annotations
+
+import shutil
+from dataclasses import dataclass
+
+from claude_statusline.core.colors import ColorManager
+from claude_statusline.formatters.time import format_duration, format_timestamp
+from claude_statusline.formatters.tokens import format_tokens
+from claude_statusline.graphs.statistics import calculate_stats
+
+
+@dataclass
+class GraphDimensions:
+    """Terminal and graph dimensions."""
+
+    term_width: int
+    term_height: int
+    graph_width: int
+    graph_height: int
+
+    @classmethod
+    def detect(cls) -> GraphDimensions:
+        """Detect terminal dimensions and calculate graph size."""
+        term_size = shutil.get_terminal_size((80, 24))
+        term_width = term_size.columns
+        term_height = term_size.lines
+
+        # Calculate graph dimensions
+        graph_width = term_width - 15  # Reserve space for Y-axis labels
+        graph_height = term_height // 3  # Each graph takes 1/3 of terminal
+
+        # Enforce minimums and maximums
+        graph_width = max(30, graph_width)
+        graph_height = max(8, min(20, graph_height))
+
+        return cls(
+            term_width=term_width,
+            term_height=term_height,
+            graph_width=graph_width,
+            graph_height=graph_height,
+        )
+
+
+class GraphRenderer:
+    """ASCII graph rendering engine."""
+
+    # Characters for graph rendering
+    DOT = "●"
+    FILL_LIGHT = "▒"
+    FILL_DARK = "░"
+
+    def __init__(
+        self,
+        colors: ColorManager | None = None,
+        dimensions: GraphDimensions | None = None,
+        token_detail: bool = True,
+    ) -> None:
+        """Initialize graph renderer.
+
+        Args:
+            colors: ColorManager instance. Creates default if None.
+            dimensions: GraphDimensions instance. Detects if None.
+            token_detail: Whether to show detailed token counts.
+        """
+        self.colors = colors or ColorManager(enabled=True)
+        self.dimensions = dimensions or GraphDimensions.detect()
+        self.token_detail = token_detail
+
+    def render_timeseries(
+        self,
+        data: list[int],
+        timestamps: list[int],
+        title: str,
+        color: str,
+    ) -> None:
+        """Render a timeseries ASCII graph.
+
+        Args:
+            data: List of values to plot
+            timestamps: Corresponding timestamps for x-axis labels
+            title: Graph title
+            color: ANSI color code for the graph
+        """
+        n = len(data)
+        if n == 0:
+            return
+
+        stats = calculate_stats(data)
+        min_val = stats.min_val
+        max_val = stats.max_val
+
+        # Avoid division by zero
+        if min_val == max_val:
+            max_val = min_val + 1
+        value_range = max_val - min_val
+
+        width = self.dimensions.graph_width
+        height = self.dimensions.graph_height
+
+        # Print title and stats
+        print()
+        print(f"{self.colors.bold}{title}{self.colors.reset}")
+        print(
+            f"{self.colors.dim}Max: {format_tokens(max_val, self.token_detail)}  "
+            f"Min: {format_tokens(min_val, self.token_detail)}  "
+            f"Points: {n}{self.colors.reset}"
+        )
+        print()
+
+        # Build the graph grid
+        grid = self._build_grid(data, min_val, max_val, value_range, width, height)
+
+        # Print grid with Y-axis labels
+        for r in range(height):
+            val = max_val - r * value_range // (height - 1)
+
+            # Show labels at top, middle, and bottom
+            if r == 0 or r == height // 2 or r == height - 1:
+                label = format_tokens(val, self.token_detail)
+            else:
+                label = ""
+
+            row_data = grid[r] if r < len(grid) else " " * width
+            print(
+                f"{label:>10} {self.colors.dim}│{self.colors.reset}"
+                f"{color}{row_data}{self.colors.reset}"
+            )
+
+        # X-axis
+        print(f"{'':>10} {self.colors.dim}└{'─' * width}{self.colors.reset}")
+
+        # Time labels
+        if timestamps:
+            first_time = format_timestamp(timestamps[0])
+            last_time = format_timestamp(timestamps[-1])
+            mid_idx = (n - 1) // 2
+            mid_time = format_timestamp(timestamps[mid_idx]) if n > 2 else ""
+
+            spacing = width // 3
+            print(
+                f"{' ':>11}{self.colors.dim}"
+                f"{first_time:<{spacing}}{mid_time}{last_time:>{spacing}}"
+                f"{self.colors.reset}"
+            )
+
+    def _build_grid(
+        self,
+        data: list[int],
+        min_val: int,
+        max_val: int,
+        value_range: int,
+        width: int,
+        height: int,
+    ) -> list[str]:
+        """Build the ASCII grid for the graph.
+
+        Args:
+            data: List of values to plot
+            min_val: Minimum value in data
+            max_val: Maximum value in data
+            value_range: max_val - min_val
+            width: Graph width in characters
+            height: Graph height in rows
+
+        Returns:
+            List of strings, one per row
+        """
+        n = len(data)
+        if n == 0:
+            return [" " * width for _ in range(height)]
+
+        # Initialize grid with empty spaces
+        grid = [[" " for _ in range(width)] for _ in range(height)]
+
+        # Calculate y positions for each data point
+        data_x = []
+        data_y = []
+        for i, val in enumerate(data):
+            # Map index to x coordinate
+            if n == 1:
+                x = width // 2
+            else:
+                x = int((i) * (width - 1) / (n - 1))
+            x = max(0, min(width - 1, x))
+
+            # Map value to y coordinate (inverted: 0=top)
+            if value_range == 0:
+                y = height // 2
+            else:
+                y = int((max_val - val) * (height - 1) / value_range)
+            y = max(0, min(height - 1, y))
+
+            data_x.append(x)
+            data_y.append(y)
+
+        # Interpolate between points to fill every x position
+        line_y = [-1.0] * width
+        for i in range(len(data) - 1):
+            x1, y1 = data_x[i], data_y[i]
+            x2, y2 = data_x[i + 1], data_y[i + 1]
+
+            # Ensure we don't go out of bounds
+            for x in range(x1, min(x2 + 1, width)):
+                if x2 == x1:
+                    y_interp = float(y1)
+                else:
+                    # Linear interpolation
+                    t = (x - x1) / (x2 - x1)
+                    y_interp = y1 + t * (y2 - y1)
+                line_y[x] = y_interp
+
+        # Draw filled area and line
+        for c in range(width):
+            if line_y[c] >= 0:
+                line_row = int(line_y[c] + 0.5)  # Round to nearest integer
+                line_row = max(0, min(height - 1, line_row))
+
+                # Fill area below the line with gradient
+                for r in range(line_row, height):
+                    if r == line_row:
+                        grid[r][c] = self.DOT
+                    elif r < line_row + 2:
+                        grid[r][c] = self.FILL_LIGHT
+                    else:
+                        grid[r][c] = self.FILL_DARK
+
+        # Mark actual data points
+        for i in range(len(data)):
+            x = data_x[i]
+            y = max(0, min(height - 1, int(data_y[i] + 0.5)))
+            grid[y][x] = self.DOT
+
+        # Convert grid to strings
+        return ["".join(row) for row in grid]
+
+    def render_summary(
+        self,
+        entries: list,  # list[StateEntry]
+        deltas: list[int],
+    ) -> None:
+        """Render summary statistics.
+
+        Args:
+            entries: List of StateEntry objects
+            deltas: List of token deltas
+        """
+        if not entries:
+            return
+
+        first = entries[0]
+        last = entries[-1]
+        duration = last.timestamp - first.timestamp
+
+        # Context window info - use current_used_tokens which represents actual context usage
+        remaining_context = 0
+        remaining_percentage = 0
+        usage_percentage = 0
+        if last.context_window_size > 0:
+            # current_used_tokens = current_input_tokens + cache_creation + cache_read
+            current_used = last.current_used_tokens
+            remaining_context = max(0, last.context_window_size - current_used)
+            remaining_percentage = remaining_context * 100 // last.context_window_size
+            usage_percentage = 100 - remaining_percentage
+
+        # Determine status based on context usage
+        if usage_percentage < 40:
+            status_color = self.colors.green
+            status_text = "Smart Zone"
+            status_hint = "You are in the smart zone"
+        elif usage_percentage < 80:
+            status_color = self.colors.yellow
+            status_text = "Dumb Zone"
+            status_hint = "You are in the dumb zone - Dex Horthy says so"
+        else:
+            status_color = self.colors.red
+            status_text = "Wrap Up Zone"
+            status_hint = "Better to wrap up and start a new session"
+
+        print()
+        print(f"{self.colors.bold}Session Summary{self.colors.reset}")
+        line_width = self.dimensions.graph_width + 11
+        print(f"{self.colors.dim}{'-' * line_width}{self.colors.reset}")
+
+        # Context remaining (before status)
+        if last.context_window_size > 0:
+            print(
+                f"  {status_color}{'Context Remaining:':<20}{self.colors.reset} "
+                f"{format_tokens(remaining_context, self.token_detail)}/{format_tokens(last.context_window_size, self.token_detail)} ({remaining_percentage}%)"
+            )
+
+        # Status indicator - highlighted
+        if last.context_window_size > 0:
+            print(
+                f"  {status_color}{self.colors.bold}>>> {status_text.upper()} <<<{self.colors.reset} "
+                f"{self.colors.dim}({status_hint}){self.colors.reset}"
+            )
+            print()
+
+        # Session details (ordered: Last Growth, I/O, Lines, Cost, Model, Duration)
+        if deltas:
+            current_growth = deltas[-1]
+            print(
+                f"  {self.colors.cyan}{'Last Growth:':<20}{self.colors.reset} "
+                f"+{format_tokens(current_growth, self.token_detail)}"
+            )
+        print(
+            f"  {self.colors.blue}{'Input Tokens:':<20}{self.colors.reset} "
+            f"{format_tokens(last.current_input_tokens, self.token_detail)}"
+        )
+        print(
+            f"  {self.colors.magenta}{'Output Tokens:':<20}{self.colors.reset} "
+            f"{format_tokens(last.current_output_tokens, self.token_detail)}"
+        )
+        if last.lines_added > 0 or last.lines_removed > 0:
+            print(
+                f"  {self.colors.dim}{'Lines Changed:':<20}{self.colors.reset} "
+                f"{self.colors.green}+{last.lines_added:,}{self.colors.reset} / "
+                f"{self.colors.red}-{last.lines_removed:,}{self.colors.reset}"
+            )
+        if last.cost_usd > 0:
+            print(
+                f"  {self.colors.yellow}{'Total Cost:':<20}{self.colors.reset} ${last.cost_usd:.4f}"
+            )
+        if last.model_id:
+            print(f"  {self.colors.dim}{'Model:':<20}{self.colors.reset} {last.model_id}")
+        print(
+            f"  {self.colors.cyan}{'Session Duration:':<20}{self.colors.reset} "
+            f"{format_duration(duration)}"
+        )
+        print()
+
+    def render_footer(self, version: str = "1.0.0", commit_hash: str = "dev") -> None:
+        """Render the footer with version info.
+
+        Args:
+            version: Package version
+            commit_hash: Git commit hash
+        """
+        print(
+            f"{self.colors.dim}Powered by {self.colors.cyan}claude-statusline"
+            f"{self.colors.dim} v{version}-{commit_hash} - "
+            f"https://github.com/luongnv89/cc-context-stats{self.colors.reset}"
+        )
+        print()

package/src/claude_statusline/graphs/statistics.py

@@ -0,0 +1,58 @@
+"""Statistical calculations for token data."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass
+class Stats:
+    """Statistical summary of a data series."""
+
+    min_val: int
+    max_val: int
+    avg_val: int
+    total: int
+    count: int
+
+
+def calculate_stats(data: list[int]) -> Stats:
+    """Calculate basic statistics for a list of integers.
+
+    Args:
+        data: List of integer values
+
+    Returns:
+        Stats object with min, max, avg, total, and count
+    """
+    if not data:
+        return Stats(min_val=0, max_val=0, avg_val=0, total=0, count=0)
+
+    min_val = min(data)
+    max_val = max(data)
+    total = sum(data)
+    count = len(data)
+    avg_val = total // count if count > 0 else 0
+
+    return Stats(min_val=min_val, max_val=max_val, avg_val=avg_val, total=total, count=count)
+
+
+def calculate_deltas(values: list[int]) -> list[int]:
+    """Calculate deltas between consecutive values.
+
+    Args:
+        values: List of values (e.g., cumulative token counts)
+
+    Returns:
+        List of deltas (length = len(values) - 1)
+    """
+    if len(values) < 2:
+        return []
+
+    deltas = []
+    for i in range(1, len(values)):
+        delta = values[i] - values[i - 1]
+        # Handle negative deltas (session reset) by showing 0
+        deltas.append(max(0, delta))
+
+    return deltas

package/tests/bash/test_install.bats

@@ -0,0 +1,29 @@
+#!/usr/bin/env bats
+
+# Test suite for install.sh
+
+setup() {
+    PROJECT_ROOT="$(cd "$BATS_TEST_DIRNAME/../.." && pwd)"
+    SCRIPT="$PROJECT_ROOT/install.sh"
+}
+
+@test "install.sh exists and is executable" {
+    [ -f "$SCRIPT" ]
+    [ -x "$SCRIPT" ]
+}
+
+@test "install.sh contains expected functions" {
+    grep -q "check_jq" "$SCRIPT"
+    grep -q "select_script" "$SCRIPT"
+    grep -q "ensure_claude_dir" "$SCRIPT"
+    grep -q "install_script" "$SCRIPT"
+    grep -q "update_settings" "$SCRIPT"
+}
+
+@test "install.sh has correct shebang" {
+    head -1 "$SCRIPT" | grep -q "#!/bin/bash"
+}
+
+@test "install.sh uses set -e for error handling" {
+    grep -q "set -e" "$SCRIPT"
+}

package/tests/bash/test_statusline_full.bats

@@ -0,0 +1,109 @@
+#!/usr/bin/env bats
+
+# Test suite for statusline-full.sh
+
+setup() {
+    PROJECT_ROOT="$(cd "$BATS_TEST_DIRNAME/../.." && pwd)"
+    SCRIPT="$PROJECT_ROOT/scripts/statusline-full.sh"
+    FIXTURES="$PROJECT_ROOT/tests/fixtures/json"
+
+    # Create a temp directory for config tests
+    TEST_HOME=$(mktemp -d)
+    export HOME="$TEST_HOME"
+    mkdir -p "$TEST_HOME/.claude"
+}
+
+teardown() {
+    rm -rf "$TEST_HOME"
+}
+
+@test "statusline-full.sh exists and is executable" {
+    [ -f "$SCRIPT" ]
+    [ -x "$SCRIPT" ]
+}
+
+@test "outputs model name from JSON input" {
+    input='{"model":{"display_name":"Opus 4.5"},"workspace":{"current_dir":"/tmp/test","project_dir":"/tmp/test"}}'
+    result=$(echo "$input" | "$SCRIPT")
+    [[ "$result" == *"Opus 4.5"* ]]
+}
+
+@test "outputs directory name from path" {
+    input='{"model":{"display_name":"Claude"},"workspace":{"current_dir":"/home/user/myproject","project_dir":"/home/user/myproject"}}'
+    result=$(echo "$input" | "$SCRIPT")
+    [[ "$result" == *"myproject"* ]]
+}
+
+@test "handles full valid input with context window" {
+    result=$(cat "$FIXTURES/valid_full.json" | "$SCRIPT")
+    [[ "$result" == *"Opus 4.5"* ]]
+    [[ "$result" == *"my-project"* ]]
+    [[ "$result" == *"free"* ]]
+}
+
+@test "shows AC indicator when autocompact enabled" {
+    input='{"model":{"display_name":"Claude"},"workspace":{"current_dir":"/tmp","project_dir":"/tmp"},"context_window":{"context_window_size":200000,"current_usage":{"input_tokens":10000,"cache_creation_input_tokens":0,"cache_read_input_tokens":0}}}'
+    result=$(echo "$input" | "$SCRIPT")
+    [[ "$result" == *"[AC:"* ]]
+}
+
+@test "shows AC:off when autocompact disabled in config" {
+    echo "autocompact=false" > "$TEST_HOME/.claude/statusline.conf"
+    input='{"model":{"display_name":"Claude"},"workspace":{"current_dir":"/tmp","project_dir":"/tmp"},"context_window":{"context_window_size":200000,"current_usage":{"input_tokens":10000,"cache_creation_input_tokens":0,"cache_read_input_tokens":0}}}'
+    result=$(echo "$input" | "$SCRIPT")
+    [[ "$result" == *"[AC:off]"* ]]
+}
+
+@test "shows exact tokens by default (token_detail=true)" {
+    input='{"model":{"display_name":"Claude"},"workspace":{"current_dir":"/tmp","project_dir":"/tmp"},"context_window":{"context_window_size":200000,"current_usage":{"input_tokens":10000,"cache_creation_input_tokens":0,"cache_read_input_tokens":0}}}'
+    result=$(echo "$input" | "$SCRIPT")
+    # Should NOT show 'k' suffix by default, should show comma-formatted number
+    [[ "$result" != *"k free"* ]]
+    [[ "$result" == *"free"* ]]
+}
+
+@test "shows abbreviated tokens when token_detail=false" {
+    echo "token_detail=false" > "$TEST_HOME/.claude/statusline.conf"
+    input='{"model":{"display_name":"Claude"},"workspace":{"current_dir":"/tmp","project_dir":"/tmp"},"context_window":{"context_window_size":200000,"current_usage":{"input_tokens":10000,"cache_creation_input_tokens":0,"cache_read_input_tokens":0}}}'
+    result=$(echo "$input" | "$SCRIPT")
+    # Should show 'k' suffix for abbreviated format
+    [[ "$result" == *"k free"* ]]
+}
+
+@test "handles missing context window gracefully" {
+    input='{"model":{"display_name":"Claude"},"workspace":{"current_dir":"/tmp/test","project_dir":"/tmp/test"}}'
+    run bash "$SCRIPT" <<< "$input"
+    [ "$status" -eq 0 ]
+}
+
+@test "calculates free tokens percentage correctly" {
+    # Low usage fixture: 30k tokens used out of 200k = 85% free
+    result=$(cat "$FIXTURES/low_usage.json" | "$SCRIPT")
+    [[ "$result" == *"free"* ]]
+}
+
+@test "uses fixture files correctly" {
+    for fixture in valid_full valid_minimal low_usage medium_usage high_usage; do
+        run bash "$SCRIPT" < "$FIXTURES/${fixture}.json"
+        [ "$status" -eq 0 ]
+    done
+}
+
+@test "shows session_id by default (show_session=true)" {
+    input='{"model":{"display_name":"Claude"},"workspace":{"current_dir":"/tmp","project_dir":"/tmp"},"session_id":"test-session-123"}'
+    result=$(echo "$input" | "$SCRIPT")
+    [[ "$result" == *"test-session-123"* ]]
+}
+
+@test "hides session_id when show_session=false" {
+    echo "show_session=false" > "$TEST_HOME/.claude/statusline.conf"
+    input='{"model":{"display_name":"Claude"},"workspace":{"current_dir":"/tmp","project_dir":"/tmp"},"session_id":"test-session-123"}'
+    result=$(echo "$input" | "$SCRIPT")
+    [[ "$result" != *"test-session-123"* ]]
+}
+
+@test "handles missing session_id gracefully" {
+    input='{"model":{"display_name":"Claude"},"workspace":{"current_dir":"/tmp","project_dir":"/tmp"}}'
+    run bash "$SCRIPT" <<< "$input"
+    [ "$status" -eq 0 ]
+}

package/tests/bash/test_statusline_git.bats

@@ -0,0 +1,42 @@
+#!/usr/bin/env bats
+
+# Test suite for statusline-git.sh
+
+setup() {
+    PROJECT_ROOT="$(cd "$BATS_TEST_DIRNAME/../.." && pwd)"
+    SCRIPT="$PROJECT_ROOT/scripts/statusline-git.sh"
+    FIXTURES="$PROJECT_ROOT/tests/fixtures/json"
+}
+
+@test "statusline-git.sh exists and is executable" {
+    [ -f "$SCRIPT" ]
+    [ -x "$SCRIPT" ]
+}
+
+@test "outputs model name from JSON input" {
+    input='{"model":{"display_name":"Opus 4.5"},"workspace":{"current_dir":"/tmp/test","project_dir":"/tmp/test"}}'
+    result=$(echo "$input" | "$SCRIPT")
+    [[ "$result" == *"Opus 4.5"* ]]
+}
+
+@test "outputs directory name" {
+    input='{"model":{"display_name":"Claude"},"workspace":{"current_dir":"/home/user/myproject","project_dir":"/tmp"}}'
+    result=$(echo "$input" | "$SCRIPT")
+    [[ "$result" == *"myproject"* ]]
+}
+
+@test "handles valid input without crashing" {
+    run bash "$SCRIPT" < "$FIXTURES/valid_full.json"
+    [ "$status" -eq 0 ]
+}
+
+@test "shows git branch when in git repo" {
+    # Use project dir which is a git repo
+    input=$(cat <<EOF
+{"model":{"display_name":"Claude"},"workspace":{"current_dir":"$PROJECT_ROOT","project_dir":"$PROJECT_ROOT"}}
+EOF
+)
+    result=$(echo "$input" | "$SCRIPT")
+    # Should contain branch name (main or master usually)
+    [[ "$result" == *"main"* ]] || [[ "$result" == *"master"* ]] || true
+}

package/tests/bash/test_statusline_minimal.bats

@@ -0,0 +1,37 @@
+#!/usr/bin/env bats
+
+# Test suite for statusline-minimal.sh
+
+setup() {
+    PROJECT_ROOT="$(cd "$BATS_TEST_DIRNAME/../.." && pwd)"
+    SCRIPT="$PROJECT_ROOT/scripts/statusline-minimal.sh"
+    FIXTURES="$PROJECT_ROOT/tests/fixtures/json"
+}
+
+@test "statusline-minimal.sh exists and is executable" {
+    [ -f "$SCRIPT" ]
+    [ -x "$SCRIPT" ]
+}
+
+@test "outputs model name from JSON input" {
+    input='{"model":{"display_name":"Opus 4.5"},"workspace":{"current_dir":"/tmp/test","project_dir":"/tmp/test"}}'
+    result=$(echo "$input" | "$SCRIPT")
+    [[ "$result" == *"Opus 4.5"* ]]
+}
+
+@test "outputs directory name" {
+    input='{"model":{"display_name":"Claude"},"workspace":{"current_dir":"/home/user/myproject","project_dir":"/tmp"}}'
+    result=$(echo "$input" | "$SCRIPT")
+    [[ "$result" == *"myproject"* ]]
+}
+
+@test "handles minimal valid input" {
+    result=$(cat "$FIXTURES/valid_minimal.json" | "$SCRIPT")
+    [[ "$result" == *"Claude"* ]]
+    [[ "$result" == *"test"* ]]
+}
+
+@test "script runs without errors on valid input" {
+    run bash "$SCRIPT" < "$FIXTURES/valid_full.json"
+    [ "$status" -eq 0 ]
+}

package/tests/fixtures/json/high_usage.json

@@ -0,0 +1,17 @@
+{
+  "model": {
+    "display_name": "Opus 4.5"
+  },
+  "workspace": {
+    "current_dir": "/home/user/project",
+    "project_dir": "/home/user/project"
+  },
+  "context_window": {
+    "context_window_size": 200000,
+    "current_usage": {
+      "input_tokens": 170000,
+      "cache_creation_input_tokens": 0,
+      "cache_read_input_tokens": 0
+    }
+  }
+}

package/tests/fixtures/json/low_usage.json

@@ -0,0 +1,17 @@
+{
+  "model": {
+    "display_name": "Opus 4.5"
+  },
+  "workspace": {
+    "current_dir": "/home/user/project",
+    "project_dir": "/home/user/project"
+  },
+  "context_window": {
+    "context_window_size": 200000,
+    "current_usage": {
+      "input_tokens": 20000,
+      "cache_creation_input_tokens": 5000,
+      "cache_read_input_tokens": 5000
+    }
+  }
+}

package/tests/fixtures/json/medium_usage.json

@@ -0,0 +1,17 @@
+{
+  "model": {
+    "display_name": "Opus 4.5"
+  },
+  "workspace": {
+    "current_dir": "/home/user/project",
+    "project_dir": "/home/user/project"
+  },
+  "context_window": {
+    "context_window_size": 200000,
+    "current_usage": {
+      "input_tokens": 100000,
+      "cache_creation_input_tokens": 20000,
+      "cache_read_input_tokens": 0
+    }
+  }
+}