cc-context-stats 1.3.0

package/src/claude_statusline/core/git.py

@@ -0,0 +1,67 @@
+"""Git integration utilities."""
+
+from __future__ import annotations
+
+import subprocess
+from pathlib import Path
+
+from claude_statusline.core.colors import CYAN, MAGENTA, RESET
+
+
+def get_git_info(project_dir: str | Path, colors_enabled: bool = True) -> str:
+    """Get git branch and change count for a directory.
+
+    Args:
+        project_dir: Path to the project directory
+        colors_enabled: Whether to include ANSI color codes
+
+    Returns:
+        Formatted string with branch and change count, or empty string if not a git repo
+    """
+    project_dir = Path(project_dir)
+    git_dir = project_dir / ".git"
+
+    if not git_dir.is_dir():
+        return ""
+
+    try:
+        # Get branch name (skip optional locks for performance)
+        result = subprocess.run(
+            ["git", "--no-optional-locks", "rev-parse", "--abbrev-ref", "HEAD"],
+            cwd=project_dir,
+            capture_output=True,
+            text=True,
+            timeout=5,
+        )
+        if result.returncode != 0:
+            return ""
+        branch = result.stdout.strip()
+
+        if not branch:
+            return ""
+
+        # Count changes
+        result = subprocess.run(
+            ["git", "--no-optional-locks", "status", "--porcelain"],
+            cwd=project_dir,
+            capture_output=True,
+            text=True,
+            timeout=5,
+        )
+        if result.returncode != 0:
+            changes = 0
+        else:
+            changes = len([line for line in result.stdout.split("\n") if line.strip()])
+
+        # Format output
+        if colors_enabled:
+            magenta, cyan, reset = MAGENTA, CYAN, RESET
+        else:
+            magenta = cyan = reset = ""
+
+        if changes > 0:
+            return f" | {magenta}{branch}{reset} {cyan}[{changes}]{reset}"
+        return f" | {magenta}{branch}{reset}"
+
+    except (subprocess.TimeoutExpired, OSError):
+        return ""

package/src/claude_statusline/core/state.py

@@ -0,0 +1,266 @@
+"""State file management for token tracking."""
+
+from __future__ import annotations
+
+import shutil
+from dataclasses import dataclass
+from pathlib import Path
+
+
+@dataclass
+class StateEntry:
+    """A single state file entry."""
+
+    timestamp: int
+    total_input_tokens: int
+    total_output_tokens: int
+    current_input_tokens: int
+    current_output_tokens: int
+    cache_creation: int
+    cache_read: int
+    cost_usd: float
+    lines_added: int
+    lines_removed: int
+    session_id: str
+    model_id: str
+    workspace_project_dir: str
+    context_window_size: int
+
+    @classmethod
+    def from_csv_line(cls, line: str) -> StateEntry | None:
+        """Parse a CSV line into a StateEntry.
+
+        Args:
+            line: CSV line with comma-separated values
+
+        Returns:
+            StateEntry or None if parsing fails
+        """
+        parts = line.strip().split(",")
+
+        # Handle old format (timestamp,tokens) and new format (14 fields)
+        if len(parts) < 2:
+            return None
+
+        try:
+            timestamp = int(parts[0])
+
+            # Old format: timestamp,tokens
+            if len(parts) == 2:
+                tokens = int(parts[1])
+                return cls(
+                    timestamp=timestamp,
+                    total_input_tokens=tokens,
+                    total_output_tokens=0,
+                    current_input_tokens=0,
+                    current_output_tokens=0,
+                    cache_creation=0,
+                    cache_read=0,
+                    cost_usd=0.0,
+                    lines_added=0,
+                    lines_removed=0,
+                    session_id="",
+                    model_id="",
+                    workspace_project_dir="",
+                    context_window_size=0,
+                )
+
+            # New format with all fields
+            def safe_int(val: str, default: int = 0) -> int:
+                try:
+                    return int(val) if val else default
+                except ValueError:
+                    return default
+
+            def safe_float(val: str, default: float = 0.0) -> float:
+                try:
+                    return float(val) if val else default
+                except ValueError:
+                    return default
+
+            return cls(
+                timestamp=timestamp,
+                total_input_tokens=safe_int(parts[1] if len(parts) > 1 else ""),
+                total_output_tokens=safe_int(parts[2] if len(parts) > 2 else ""),
+                current_input_tokens=safe_int(parts[3] if len(parts) > 3 else ""),
+                current_output_tokens=safe_int(parts[4] if len(parts) > 4 else ""),
+                cache_creation=safe_int(parts[5] if len(parts) > 5 else ""),
+                cache_read=safe_int(parts[6] if len(parts) > 6 else ""),
+                cost_usd=safe_float(parts[7] if len(parts) > 7 else ""),
+                lines_added=safe_int(parts[8] if len(parts) > 8 else ""),
+                lines_removed=safe_int(parts[9] if len(parts) > 9 else ""),
+                session_id=parts[10] if len(parts) > 10 else "",
+                model_id=parts[11] if len(parts) > 11 else "",
+                workspace_project_dir=parts[12] if len(parts) > 12 else "",
+                context_window_size=safe_int(parts[13] if len(parts) > 13 else ""),
+            )
+
+        except (ValueError, IndexError):
+            return None
+
+    def to_csv_line(self) -> str:
+        """Convert entry to CSV line."""
+        return ",".join(
+            str(x)
+            for x in [
+                self.timestamp,
+                self.total_input_tokens,
+                self.total_output_tokens,
+                self.current_input_tokens,
+                self.current_output_tokens,
+                self.cache_creation,
+                self.cache_read,
+                self.cost_usd,
+                self.lines_added,
+                self.lines_removed,
+                self.session_id,
+                self.model_id,
+                self.workspace_project_dir,
+                self.context_window_size,
+            ]
+        )
+
+    @property
+    def total_tokens(self) -> int:
+        """Get combined input + output tokens."""
+        return self.total_input_tokens + self.total_output_tokens
+
+    @property
+    def current_used_tokens(self) -> int:
+        """Get current context usage (input + cache)."""
+        return self.current_input_tokens + self.cache_creation + self.cache_read
+
+
+class StateFile:
+    """Manage state files for token tracking."""
+
+    STATE_DIR = Path.home() / ".claude" / "statusline"
+    OLD_STATE_DIR = Path.home() / ".claude"
+
+    def __init__(self, session_id: str | None = None) -> None:
+        """Initialize state file manager.
+
+        Args:
+            session_id: Optional session ID. If not provided, uses latest session.
+        """
+        self.session_id = session_id
+        self._ensure_state_dir()
+        self._migrate_old_files()
+
+    def _ensure_state_dir(self) -> None:
+        """Create state directory if it doesn't exist."""
+        self.STATE_DIR.mkdir(parents=True, exist_ok=True)
+
+    def _migrate_old_files(self) -> None:
+        """Migrate old state files from ~/.claude/ to ~/.claude/statusline/."""
+        for old_file in self.OLD_STATE_DIR.glob("statusline*.state"):
+            if old_file.is_file():
+                new_file = self.STATE_DIR / old_file.name
+                if not new_file.exists():
+                    try:
+                        shutil.move(str(old_file), str(new_file))
+                    except OSError:
+                        pass
+                else:
+                    try:
+                        old_file.unlink()
+                    except OSError:
+                        pass
+
+    @property
+    def file_path(self) -> Path:
+        """Get the state file path for the current session."""
+        if self.session_id:
+            return self.STATE_DIR / f"statusline.{self.session_id}.state"
+        return self.STATE_DIR / "statusline.state"
+
+    def find_latest_state_file(self) -> Path | None:
+        """Find the most recently modified state file.
+
+        Returns:
+            Path to the latest state file, or None if no files exist
+        """
+        if self.session_id:
+            file_path = self.STATE_DIR / f"statusline.{self.session_id}.state"
+            return file_path if file_path.exists() else None
+
+        # Find most recent state file by modification time
+        state_files = list(self.STATE_DIR.glob("statusline.*.state"))
+        if not state_files:
+            # Try default state file
+            default = self.STATE_DIR / "statusline.state"
+            return default if default.exists() else None
+
+        return max(state_files, key=lambda f: f.stat().st_mtime)
+
+    def read_history(self) -> list[StateEntry]:
+        """Read all entries from the state file.
+
+        Returns:
+            List of StateEntry objects
+        """
+        file_path = self.find_latest_state_file()
+        if not file_path or not file_path.exists():
+            return []
+
+        entries = []
+        try:
+            content = file_path.read_text()
+            for line in content.splitlines():
+                if line.strip():
+                    entry = StateEntry.from_csv_line(line)
+                    if entry:
+                        entries.append(entry)
+        except OSError:
+            pass
+
+        return entries
+
+    def read_last_entry(self) -> StateEntry | None:
+        """Read only the last entry from the state file.
+
+        Returns:
+            The last StateEntry or None if file is empty/missing
+        """
+        # Use file_path for specific session, find_latest for unspecified session
+        file_path = self.file_path if self.session_id else self.find_latest_state_file()
+        if not file_path or not file_path.exists():
+            return None
+
+        try:
+            content = file_path.read_text()
+            lines = content.splitlines()
+            for line in reversed(lines):
+                if line.strip():
+                    return StateEntry.from_csv_line(line)
+        except OSError:
+            pass
+
+        return None
+
+    def append_entry(self, entry: StateEntry) -> None:
+        """Append an entry to the state file.
+
+        Args:
+            entry: StateEntry to append
+        """
+        try:
+            with open(self.file_path, "a") as f:
+                f.write(f"{entry.to_csv_line()}\n")
+        except OSError:
+            pass
+
+    def list_sessions(self) -> list[str]:
+        """List all available session IDs.
+
+        Returns:
+            List of session ID strings
+        """
+        sessions = []
+        for file_path in self.STATE_DIR.glob("statusline.*.state"):
+            name = file_path.stem  # statusline.{session_id}
+            if name.startswith("statusline."):
+                session_id = name[11:]  # Remove "statusline." prefix
+                if session_id:
+                    sessions.append(session_id)
+        return sessions

package/src/claude_statusline/formatters/__init__.py

@@ -0,0 +1 @@
+"""Formatting utilities for claude-statusline."""

package/src/claude_statusline/formatters/time.py

@@ -0,0 +1,50 @@
+"""Time and duration formatting utilities."""
+
+from __future__ import annotations
+
+import time
+from datetime import datetime
+
+
+def format_timestamp(ts: int) -> str:
+    """Format Unix timestamp as time string.
+
+    Args:
+        ts: Unix timestamp (seconds since epoch)
+
+    Returns:
+        Formatted time string like "14:30"
+    """
+    try:
+        return datetime.fromtimestamp(ts).strftime("%H:%M")
+    except (ValueError, OSError):
+        return str(ts)
+
+
+def format_duration(seconds: int) -> str:
+    """Format duration in seconds as human-readable string.
+
+    Args:
+        seconds: Duration in seconds
+
+    Returns:
+        Formatted string like "2h 30m" or "45m" or "30s"
+    """
+    hours = seconds // 3600
+    minutes = (seconds % 3600) // 60
+
+    if hours > 0:
+        return f"{hours}h {minutes}m"
+    elif minutes > 0:
+        return f"{minutes}m"
+    else:
+        return f"{seconds}s"
+
+
+def get_current_timestamp() -> int:
+    """Get current Unix timestamp.
+
+    Returns:
+        Current time as Unix timestamp
+    """
+    return int(time.time())

package/src/claude_statusline/formatters/tokens.py

@@ -0,0 +1,70 @@
+"""Token formatting utilities."""
+
+from __future__ import annotations
+
+
+def format_tokens(count: int, detail: bool = True) -> str:
+    """Format token count for display.
+
+    Args:
+        count: Number of tokens
+        detail: If True, show exact count with commas. If False, use abbreviated format.
+
+    Returns:
+        Formatted string like "64,000" or "64.0k"
+    """
+    if detail:
+        return f"{count:,}"
+    else:
+        if count >= 1_000_000:
+            return f"{count / 1_000_000:.1f}M"
+        elif count >= 1_000:
+            return f"{count / 1_000:.1f}k"
+        else:
+            return str(count)
+
+
+def format_percentage(value: float, decimals: int = 1) -> str:
+    """Format a percentage value.
+
+    Args:
+        value: Percentage value (0-100)
+        decimals: Number of decimal places
+
+    Returns:
+        Formatted percentage string like "75.5%"
+    """
+    return f"{value:.{decimals}f}%"
+
+
+def calculate_context_usage(
+    used_tokens: int,
+    total_size: int,
+    autocompact_enabled: bool = True,
+    autocompact_ratio: float = 0.225,
+) -> tuple[int, float, int]:
+    """Calculate context window usage statistics.
+
+    Args:
+        used_tokens: Number of tokens currently used
+        total_size: Total context window size
+        autocompact_enabled: Whether autocompact is enabled
+        autocompact_ratio: Ratio of context window reserved for autocompact (default 22.5%)
+
+    Returns:
+        Tuple of (free_tokens, free_percentage, autocompact_buffer)
+    """
+    if total_size <= 0:
+        return 0, 0.0, 0
+
+    autocompact_buffer = int(total_size * autocompact_ratio)
+
+    if autocompact_enabled:
+        free_tokens = total_size - used_tokens - autocompact_buffer
+    else:
+        free_tokens = total_size - used_tokens
+
+    free_tokens = max(0, free_tokens)
+    free_pct = (free_tokens * 100.0) / total_size
+
+    return free_tokens, free_pct, autocompact_buffer

package/src/claude_statusline/graphs/__init__.py

@@ -0,0 +1 @@
+"""Graph rendering utilities for token visualization."""