cc-context-stats 1.8.0 → 1.8.2

package/src/claude_statusline/core/config.py

@@ -1,165 +0,0 @@
-"""Configuration management for statusline."""
-
-from __future__ import annotations
-
-import sys
-from dataclasses import dataclass, field
-from pathlib import Path
-from typing import Any
-
-from claude_statusline.core.colors import parse_color
-
-# Color config keys and which ColorManager slot they map to
-_COLOR_KEYS: dict[str, str] = {
-    "color_green": "green",
-    "color_yellow": "yellow",
-    "color_red": "red",
-    "color_blue": "blue",
-    "color_magenta": "magenta",
-    "color_cyan": "cyan",
-}
-
-
-@dataclass
-class Config:
-    """Configuration settings for the statusline."""
-
-    autocompact: bool = True
-    token_detail: bool = True
-    show_delta: bool = True
-    show_session: bool = True
-    show_io_tokens: bool = True
-    reduced_motion: bool = False
-    show_mi: bool = True
-    mi_curve_beta: float = 1.5
-
-    # Custom color overrides (slot_name -> ANSI code)
-    color_overrides: dict[str, str] = field(default_factory=dict)
-
-    _config_path: Path = field(default_factory=lambda: Path.home() / ".claude" / "statusline.conf")
-
-    @classmethod
-    def load(cls, config_path: str | Path | None = None) -> Config:
-        """Load configuration from file.
-
-        Args:
-            config_path: Path to config file. Defaults to ~/.claude/statusline.conf
-
-        Returns:
-            Config instance with loaded settings
-        """
-        config = cls()
-        if config_path:
-            config._config_path = Path(config_path).expanduser()
-
-        if not config._config_path.exists():
-            config._create_default()
-            return config
-
-        config._read_config()
-        return config
-
-    def _create_default(self) -> None:
-        """Create default config file if it doesn't exist."""
-        try:
-            self._config_path.parent.mkdir(parents=True, exist_ok=True)
-            self._config_path.write_text(
-                """# Autocompact setting - sync with Claude Code's /config
-autocompact=true
-
-# Token display format
-token_detail=true
-
-# Show token delta since last refresh (adds file I/O on every refresh)
-# Disable if you don't need it to reduce overhead
-show_delta=true
-
-# Show session_id in status line
-show_session=true
-
-# Disable rotating text animations
-reduced_motion=false
-
-# Model Intelligence (MI) score display
-show_mi=true
-
-# MI degradation curve shape (higher = steeper initial drop)
-# mi_curve_beta=1.5
-
-# Custom colors - use named colors or hex (#rrggbb)
-# Available color slots: color_green, color_yellow, color_red,
-#   color_blue, color_magenta, color_cyan
-# Named colors: black, red, green, yellow, blue, magenta, cyan, white,
-#   bright_black, bright_red, bright_green, bright_yellow,
-#   bright_blue, bright_magenta, bright_cyan, bright_white
-# Examples:
-#   color_green=#7dcfff
-#   color_yellow=bright_yellow
-#   color_red=#f7768e
-"""
-            )
-        except OSError as e:
-            sys.stderr.write(
-                f"[statusline] warning: failed to create config {self._config_path}: {e}\n"
-            )
-
-    def _read_config(self) -> None:
-        """Read settings from config file."""
-        try:
-            content = self._config_path.read_text()
-            for line in content.splitlines():
-                line = line.strip()
-                if line.startswith("#") or "=" not in line:
-                    continue
-                key, value = line.split("=", 1)
-                key = key.strip()
-                raw_value = value.strip()
-                value_lower = raw_value.lower()
-
-                if key == "autocompact":
-                    self.autocompact = value_lower != "false"
-                elif key == "token_detail":
-                    self.token_detail = value_lower != "false"
-                elif key == "show_delta":
-                    self.show_delta = value_lower != "false"
-                elif key == "show_session":
-                    self.show_session = value_lower != "false"
-                elif key == "show_io_tokens":
-                    self.show_io_tokens = value_lower != "false"
-                elif key == "reduced_motion":
-                    self.reduced_motion = value_lower != "false"
-                elif key == "show_mi":
-                    self.show_mi = value_lower != "false"
-                elif key == "mi_curve_beta":
-                    try:
-                        self.mi_curve_beta = float(raw_value)
-                    except ValueError:
-                        pass
-                elif key in _COLOR_KEYS:
-                    slot = _COLOR_KEYS[key]
-                    ansi = parse_color(raw_value)
-                    if ansi:
-                        self.color_overrides[slot] = ansi
-                    else:
-                        sys.stderr.write(
-                            f"[statusline] warning: unrecognized color value "
-                            f"'{raw_value}' for {key}\n"
-                        )
-        except (OSError, UnicodeDecodeError) as e:
-            sys.stderr.write(
-                f"[statusline] warning: failed to read config {self._config_path}: {e}\n"
-            )
-
-    def to_dict(self) -> dict[str, Any]:
-        """Convert config to dictionary."""
-        return {
-            "autocompact": self.autocompact,
-            "token_detail": self.token_detail,
-            "show_delta": self.show_delta,
-            "show_session": self.show_session,
-            "show_io_tokens": self.show_io_tokens,
-            "reduced_motion": self.reduced_motion,
-            "show_mi": self.show_mi,
-            "mi_curve_beta": self.mi_curve_beta,
-            "color_overrides": dict(self.color_overrides),
-        }

package/src/claude_statusline/core/git.py

@@ -1,78 +0,0 @@
-"""Git integration utilities."""
-
-from __future__ import annotations
-
-import subprocess
-from pathlib import Path
-
-from claude_statusline.core.colors import CYAN, MAGENTA, RESET, ColorManager
-
-
-def get_git_info(
-    project_dir: str | Path,
-    colors_enabled: bool = True,
-    color_manager: ColorManager | None = None,
-) -> 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. Deprecated —
-            prefer passing a ColorManager via color_manager instead.
-        color_manager: Optional ColorManager for custom colors. If provided,
-            colors_enabled is ignored (the manager handles that).
-
-    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 — use ColorManager if provided, else fallback to constants
-        if color_manager is not None:
-            magenta = color_manager.magenta
-            cyan = color_manager.cyan
-            reset = color_manager.reset
-        elif 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

@@ -1,323 +0,0 @@
-"""State file management for token tracking."""
-
-from __future__ import annotations
-
-import os
-import shutil
-import sys
-import tempfile
-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.replace(",", "_"),
-                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
-
-
-def _validate_session_id(session_id: str) -> None:
-    """Validate that a session ID does not contain dangerous path characters.
-
-    Args:
-        session_id: Session ID to validate
-
-    Raises:
-        ValueError: If session_id contains '/', '\\', '..', or null bytes
-    """
-    for bad in ("/", "\\", "..", "\0"):
-        if bad in session_id:
-            raise ValueError(
-                f"Invalid session_id: contains '{bad}'. "
-                "Session IDs must not contain '/', '\\', '..', or null bytes."
-            )
-
-
-class StateFile:
-    """Manage state files for token tracking."""
-
-    STATE_DIR = Path.home() / ".claude" / "statusline"
-    OLD_STATE_DIR = Path.home() / ".claude"
-    ROTATION_THRESHOLD = 10_000
-    ROTATION_KEEP = 5_000
-
-    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.
-        """
-        if session_id is not None:
-            _validate_session_id(session_id)
-        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 as e:
-            sys.stderr.write(f"[statusline] warning: failed to read state history {file_path}: {e}\n")
-
-        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 as e:
-            sys.stderr.write(f"[statusline] warning: failed to read last entry {file_path}: {e}\n")
-
-        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 as e:
-            sys.stderr.write(f"[statusline] warning: failed to write state {self.file_path}: {e}\n")
-            return
-        self._maybe_rotate()
-
-    def _maybe_rotate(self) -> None:
-        """Rotate state file if it exceeds the line threshold.
-
-        If the file has more than ROTATION_THRESHOLD lines, truncate to
-        the most recent ROTATION_KEEP lines via atomic temp-file + rename.
-        """
-        file_path = self.file_path
-        try:
-            if not file_path.exists():
-                return
-            lines = file_path.read_text().splitlines(keepends=True)
-            if len(lines) <= self.ROTATION_THRESHOLD:
-                return
-            keep = lines[-self.ROTATION_KEEP :]
-            fd = tempfile.NamedTemporaryFile(
-                dir=str(self.STATE_DIR), delete=False, mode="w", suffix=".tmp"
-            )
-            try:
-                fd.writelines(keep)
-                fd.close()
-                os.replace(fd.name, str(file_path))
-            except BaseException:
-                fd.close()
-                try:
-                    os.unlink(fd.name)
-                except OSError:
-                    pass
-                raise
-        except OSError as e:
-            sys.stderr.write(f"[statusline] warning: failed to rotate state file {file_path}: {e}\n")
-
-    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

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

package/src/claude_statusline/formatters/layout.py

@@ -1,67 +0,0 @@
-"""Layout utilities for fitting statusline output to terminal width."""
-
-from __future__ import annotations
-
-import re
-import shutil
-
-# Pattern to strip ANSI escape sequences
-_ANSI_RE = re.compile(r"\033\[[0-9;]*m")
-
-
-def visible_width(s: str) -> int:
-    """Return the visible width of a string after stripping ANSI escape sequences."""
-    return len(_ANSI_RE.sub("", s))
-
-
-def get_terminal_width() -> int:
-    """Return the terminal width in columns.
-
-    When running inside Claude Code's statusline subprocess, neither $COLUMNS
-    nor tput/shutil can detect the real terminal width (they always return 80).
-    If COLUMNS is not explicitly set and shutil falls back to 80, we use a
-    generous default of 200 so that no parts are unnecessarily dropped;
-    Claude Code's own UI handles any overflow/truncation.
-    """
-    import os
-
-    # If COLUMNS is explicitly set, trust it (real terminal or test override)
-    if os.environ.get("COLUMNS"):
-        return shutil.get_terminal_size().columns
-    # No COLUMNS env var — likely a Claude Code subprocess with no real TTY.
-    # shutil will fall back to 80, which is too narrow. Use 200 instead.
-    cols = shutil.get_terminal_size(fallback=(200, 24)).columns
-    return 200 if cols == 80 else cols
-
-
-def fit_to_width(parts: list[str], max_width: int) -> str:
-    """Assemble parts into a single line that fits within max_width.
-
-    Parts are added in priority order (first = highest priority).
-    The first part (base) is always included. Subsequent parts are
-    included only if adding them does not exceed max_width.
-    Empty parts are skipped.
-
-    Args:
-        parts: List of strings in priority order (highest first).
-        max_width: Maximum visible width allowed.
-
-    Returns:
-        Assembled string that fits within max_width.
-    """
-    if not parts:
-        return ""
-
-    # Base part is always included
-    result = parts[0]
-    current_width = visible_width(result)
-
-    for part in parts[1:]:
-        if not part:
-            continue
-        part_width = visible_width(part)
-        if current_width + part_width <= max_width:
-            result += part
-            current_width += part_width
-
-    return result

package/src/claude_statusline/formatters/time.py

@@ -1,50 +0,0 @@
-"""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())