cc-context-stats 1.8.0 → 1.8.2

package/src/claude_statusline/cli/explain.py

@@ -1,228 +0,0 @@
-"""Diagnostic command that dumps the raw JSON context from Claude Code.
-
-Usage:
-    echo '{"model":...}' | context-stats explain
-    echo '{"model":...}' | context-stats explain --no-color
-
-Reads the same JSON that Claude Code pipes to the statusline script,
-pretty-prints every field with labels, and shows how cc-context-stats
-interprets them. Useful for debugging blank or missing modules.
-"""
-
-from __future__ import annotations
-
-import json
-import sys
-
-from claude_statusline.core.colors import ColorManager
-from claude_statusline.core.config import Config
-from claude_statusline.formatters.tokens import format_tokens
-
-
-def _pct_color(colors: ColorManager, pct: float) -> str:
-    """Return ANSI color based on free-space percentage."""
-    if pct > 50:
-        return colors.green
-    if pct > 25:
-        return colors.yellow
-    return colors.red
-
-
-def _fv(colors: ColorManager, value: object) -> str:
-    """Format a value for display, handling None gracefully."""
-    if value is None:
-        return f"{colors.dim}(absent){colors.reset}"
-    if isinstance(value, float):
-        return f"{value:.4f}"
-    return str(value)
-
-
-def _render_model(data: dict, colors: ColorManager) -> None:
-    model = data.get("model", {})
-    print(f"{colors.bold}Model{colors.reset}")
-    print(f"  display_name:  {_fv(colors, model.get('display_name'))}")
-    print(f"  id:            {_fv(colors, model.get('id'))}")
-    print(f"  api_name:      {_fv(colors, model.get('api_name'))}")
-    print()
-
-
-def _render_workspace(data: dict, colors: ColorManager) -> None:
-    workspace = data.get("workspace", {})
-    print(f"{colors.bold}Workspace{colors.reset}")
-    print(f"  current_dir:   {_fv(colors, workspace.get('current_dir'))}")
-    print(f"  project_dir:   {_fv(colors, workspace.get('project_dir'))}")
-    print()
-
-
-def _render_context_window(data: dict, colors: ColorManager, config: Config) -> None:
-    cw = data.get("context_window", {})
-    print(f"{colors.bold}Context Window{colors.reset}")
-    total_size = cw.get("context_window_size", 0)
-    print(
-        f"  window_size:   "
-        f"{format_tokens(total_size, config.token_detail) if total_size else _fv(colors, None)}"
-    )
-
-    total_in = cw.get("total_input_tokens")
-    total_out = cw.get("total_output_tokens")
-    print(
-        f"  total_input:   "
-        f"{format_tokens(total_in, config.token_detail) if total_in else _fv(colors, total_in)}"
-    )
-    print(
-        f"  total_output:  "
-        f"{format_tokens(total_out, config.token_detail) if total_out else _fv(colors, total_out)}"
-    )
-
-    used_pct = cw.get("used_percentage")
-    remaining_pct = cw.get("remaining_percentage")
-    print(f"  used_pct:      {_fv(colors, used_pct)}")
-    print(f"  remaining_pct: {_fv(colors, remaining_pct)}")
-
-    cu = cw.get("current_usage")
-    if cu:
-        _render_current_usage(cu, total_size, colors, config)
-    else:
-        print(f"  current_usage: {colors.dim}(absent — no API call yet this session){colors.reset}")
-    print()
-
-
-def _render_current_usage(cu: dict, total_size: int, colors: ColorManager, config: Config) -> None:
-    input_tok = cu.get("input_tokens", 0)
-    output_tok = cu.get("output_tokens", 0)
-    cache_create = cu.get("cache_creation_input_tokens", 0)
-    cache_read = cu.get("cache_read_input_tokens", 0)
-    used_tokens = input_tok + cache_create + cache_read
-
-    print(f"\n  {colors.bold}Current Usage{colors.reset}")
-    print(f"    input_tokens:            {format_tokens(input_tok, config.token_detail)}")
-    print(f"    output_tokens:           {format_tokens(output_tok, config.token_detail)}")
-    print(f"    cache_creation_tokens:   {format_tokens(cache_create, config.token_detail)}")
-    print(f"    cache_read_tokens:       {format_tokens(cache_read, config.token_detail)}")
-
-    print(f"\n  {colors.bold}Derived Values{colors.reset}")
-    print(
-        f"    context_used (in+cache): "
-        f"{colors.cyan}{format_tokens(used_tokens, config.token_detail)}{colors.reset}"
-    )
-
-    if total_size > 0:
-        free = total_size - used_tokens
-        free_pct = (free * 100.0) / total_size
-        color = _pct_color(colors, free_pct)
-        print(
-            f"    free_tokens:             "
-            f"{color}{format_tokens(max(0, free), config.token_detail)} ({free_pct:.1f}%){colors.reset}"
-        )
-
-        if config.autocompact:
-            ac_buffer = int(total_size * 0.225)
-            effective_free = max(0, free - ac_buffer)
-            eff_pct = (effective_free * 100.0) / total_size
-            eff_color = _pct_color(colors, eff_pct)
-            print(
-                f"    autocompact_buffer:      "
-                f"{colors.dim}{format_tokens(ac_buffer, config.token_detail)}{colors.reset}"
-            )
-            print(
-                f"    effective_free (w/ AC):   "
-                f"{eff_color}{format_tokens(effective_free, config.token_detail)}"
-                f" ({eff_pct:.1f}%){colors.reset}"
-            )
-        else:
-            print(f"    autocompact:             {colors.dim}disabled{colors.reset}")
-
-
-def _render_cost(data: dict, colors: ColorManager) -> None:
-    cost = data.get("cost", {})
-    if not cost:
-        return
-    print(f"{colors.bold}Cost{colors.reset}")
-    cost_usd = cost.get("total_cost_usd")
-    print(
-        f"  total_cost_usd:    {f'${cost_usd:.4f}' if cost_usd is not None else _fv(colors, None)}"
-    )
-    print(f"  total_duration_ms: {_fv(colors, cost.get('total_duration_ms'))}")
-    print(f"  lines_added:       {_fv(colors, cost.get('total_lines_added'))}")
-    print(f"  lines_removed:     {_fv(colors, cost.get('total_lines_removed'))}")
-    print()
-
-
-def _render_session(data: dict, colors: ColorManager) -> None:
-    print(f"{colors.bold}Session{colors.reset}")
-    print(f"  session_id:        {_fv(colors, data.get('session_id'))}")
-    print(f"  version:           {_fv(colors, data.get('version'))}")
-    print(f"  transcript_path:   {_fv(colors, data.get('transcript_path'))}")
-    print(f"  exceeds_200k:      {_fv(colors, data.get('exceeds_200k_tokens'))}")
-    print()
-
-
-def _render_extensions(data: dict, colors: ColorManager) -> None:
-    vim = data.get("vim")
-    agent = data.get("agent")
-    output_style = data.get("output_style")
-    if vim is None and agent is None and output_style is None:
-        return
-    print(f"{colors.bold}Extensions{colors.reset}")
-    if vim is not None:
-        vim_mode = vim.get("mode") if isinstance(vim, dict) else vim
-        print(f"  vim_mode:          {_fv(colors, vim_mode)}")
-    if agent is not None:
-        agent_name = agent.get("name") if isinstance(agent, dict) else agent
-        print(f"  agent:             {_fv(colors, agent_name)}")
-    if output_style is not None:
-        style_name = output_style.get("name") if isinstance(output_style, dict) else output_style
-        print(f"  output_style:      {_fv(colors, style_name)}")
-    print()
-
-
-def _render_config(config: Config, colors: ColorManager) -> None:
-    print(
-        f"{colors.bold}Active Config{colors.reset}  "
-        f"{colors.dim}(~/.claude/statusline.conf){colors.reset}"
-    )
-    for k, v in config.to_dict().items():
-        if k == "color_overrides":
-            if v:
-                print(f"  {k}:")
-                for slot, ansi_code in v.items():
-                    print(f"    {slot}: {ansi_code}████{colors.reset}")
-            continue
-        print(f"  {k}: {v}")
-    print()
-
-
-def _render_raw_json(data: dict, colors: ColorManager) -> None:
-    print(f"{colors.bold}Raw JSON{colors.reset}")
-    print(f"{colors.dim}{json.dumps(data, indent=2)}{colors.reset}")
-    print()
-
-
-def run_explain(data: dict, no_color: bool = False) -> None:
-    """Print a diagnostic dump of the Claude Code session JSON.
-
-    Args:
-        data: Parsed JSON dict from stdin.
-        no_color: If True, suppress ANSI color codes.
-    """
-    config = Config.load()
-
-    # Respect --no-color flag and non-TTY output
-    color_enabled = not no_color and sys.stdout.isatty()
-    colors = ColorManager(enabled=color_enabled, overrides=config.color_overrides)
-
-    print(f"\n{colors.bold}cc-context-stats explain{colors.reset}")
-    print(f"{colors.dim}{'─' * 60}{colors.reset}")
-    print(
-        f"{colors.dim}Shows how cc-context-stats interprets Claude Code's JSON context."
-        f"{colors.reset}\n"
-    )
-
-    _render_model(data, colors)
-    _render_workspace(data, colors)
-    _render_context_window(data, colors, config)
-    _render_cost(data, colors)
-    _render_session(data, colors)
-    _render_extensions(data, colors)
-    _render_config(config, colors)
-    _render_raw_json(data, colors)

package/src/claude_statusline/cli/statusline.py

@@ -1,184 +0,0 @@
-#!/usr/bin/env python3
-"""CLI entry point for claude-statusline command.
-
-Usage: Copy to ~/.claude/statusline.py and make executable, or install via pip.
-
-Configuration:
-Create/edit ~/.claude/statusline.conf and set:
-
-  autocompact=true   (when autocompact is enabled in Claude Code - default)
-  autocompact=false  (when you disable autocompact via /config in Claude Code)
-
-  token_detail=true  (show exact token count like 64,000 - default)
-  token_detail=false (show abbreviated tokens like 64.0k)
-
-  show_delta=true    (show token delta since last refresh like [+2,500] - default)
-  show_delta=false   (disable delta display - saves file I/O on every refresh)
-
-  show_session=true  (show session_id in status line - default)
-  show_session=false (hide session_id from status line)
-
-When AC is enabled, 22.5% of context window is reserved for autocompact buffer.
-"""
-
-from __future__ import annotations
-
-import json
-import sys
-
-from claude_statusline.core.colors import ColorManager
-from claude_statusline.core.config import Config
-from claude_statusline.core.git import get_git_info
-from claude_statusline.core.state import StateEntry, StateFile
-from claude_statusline.formatters.layout import fit_to_width, get_terminal_width
-from claude_statusline.formatters.time import get_current_timestamp
-from claude_statusline.formatters.tokens import calculate_context_usage, format_tokens
-
-
-def main() -> None:
-    """Main entry point for claude-statusline CLI."""
-    try:
-        data = json.load(sys.stdin)
-    except json.JSONDecodeError:
-        print("[Claude] ~")
-        return
-
-    # Extract data
-    cwd = data.get("workspace", {}).get("current_dir", "~")
-    project_dir = data.get("workspace", {}).get("project_dir", cwd)
-    model = data.get("model", {}).get("display_name", "Claude")
-    dir_name = cwd.rsplit("/", 1)[-1] if "/" in cwd else cwd or "~"
-
-    # Read settings from config file
-    config = Config.load()
-
-    # Build color manager with any user overrides
-    colors = ColorManager(enabled=True, overrides=config.color_overrides)
-
-    # Git info (pass color manager for configurable branch/change colors)
-    git_info = get_git_info(project_dir, color_manager=colors)
-
-    # Extract session_id once for reuse
-    session_id = data.get("session_id")
-
-    # Context window calculation
-    context_info = ""
-    ac_info = ""
-    delta_info = ""
-    mi_info = ""
-    session_info = ""
-
-    total_size = data.get("context_window", {}).get("context_window_size", 0)
-    current_usage = data.get("context_window", {}).get("current_usage")
-    total_input_tokens = data.get("context_window", {}).get("total_input_tokens", 0)
-    total_output_tokens = data.get("context_window", {}).get("total_output_tokens", 0)
-    cost_usd = data.get("cost", {}).get("total_cost_usd", 0)
-    lines_added = data.get("cost", {}).get("total_lines_added", 0)
-    lines_removed = data.get("cost", {}).get("total_lines_removed", 0)
-    model_id = data.get("model", {}).get("id", "")
-    workspace_project_dir = data.get("workspace", {}).get("project_dir", "")
-
-    if total_size > 0 and current_usage:
-        # Get tokens from current_usage (includes cache)
-        input_tokens = current_usage.get("input_tokens", 0)
-        cache_creation = current_usage.get("cache_creation_input_tokens", 0)
-        cache_read = current_usage.get("cache_read_input_tokens", 0)
-
-        # Total used from current request
-        used_tokens = input_tokens + cache_creation + cache_read
-
-        # Calculate context usage
-        free_tokens, free_pct, autocompact_buffer = calculate_context_usage(
-            used_tokens,
-            total_size,
-            config.autocompact,
-        )
-
-        if config.autocompact:
-            buffer_k = autocompact_buffer // 1000
-            ac_info = f" {colors.dim}[AC:{buffer_k}k]{colors.reset}"
-        else:
-            ac_info = f" {colors.dim}[AC:off]{colors.reset}"
-
-        # Format tokens based on token_detail setting
-        free_display = format_tokens(free_tokens, config.token_detail)
-
-        # Color based on free percentage
-        free_pct_int = int(free_pct)
-        if free_pct_int > 50:
-            ctx_color = colors.green
-        elif free_pct_int > 25:
-            ctx_color = colors.yellow
-        else:
-            ctx_color = colors.red
-
-        context_info = f" | {ctx_color}{free_display} ({free_pct:.1f}%){colors.reset}"
-
-        # Read previous entry if needed for delta OR MI
-        if config.show_delta or config.show_mi:
-            state_file = StateFile(session_id)
-            prev_entry = state_file.read_last_entry()
-
-            prev_tokens = prev_entry.current_used_tokens if prev_entry else 0
-            has_prev = prev_entry is not None
-
-            # Build current entry
-            cur_input_tokens = current_usage.get("input_tokens", 0)
-            cur_output_tokens = current_usage.get("output_tokens", 0)
-
-            entry = StateEntry(
-                timestamp=get_current_timestamp(),
-                total_input_tokens=total_input_tokens,
-                total_output_tokens=total_output_tokens,
-                current_input_tokens=cur_input_tokens,
-                current_output_tokens=cur_output_tokens,
-                cache_creation=cache_creation,
-                cache_read=cache_read,
-                cost_usd=cost_usd,
-                lines_added=lines_added,
-                lines_removed=lines_removed,
-                session_id=session_id or "",
-                model_id=model_id,
-                workspace_project_dir=workspace_project_dir,
-                context_window_size=total_size,
-            )
-
-            # Calculate and display token delta if enabled
-            if config.show_delta:
-                delta = used_tokens - prev_tokens
-                if has_prev and delta > 0:
-                    delta_display = format_tokens(delta, config.token_detail)
-                    delta_info = f" {colors.dim}[+{delta_display}]{colors.reset}"
-
-            # Calculate and display MI score if enabled
-            if config.show_mi:
-                from claude_statusline.graphs.intelligence import (
-                    calculate_intelligence,
-                    format_mi_score,
-                    get_mi_color,
-                )
-
-                mi_score = calculate_intelligence(
-                    entry, prev_entry, total_size, config.mi_curve_beta
-                )
-                mi_color_name = get_mi_color(mi_score.mi)
-                mi_color = getattr(colors, mi_color_name)
-                mi_info = f" {mi_color}MI:{format_mi_score(mi_score.mi)}{colors.reset}"
-
-            # Only append if context usage changed (avoid duplicates from multiple refreshes)
-            if not has_prev or used_tokens != prev_tokens:
-                state_file.append_entry(entry)
-
-    # Display session_id if enabled
-    if config.show_session and session_id:
-        session_info = f" {colors.dim}{session_id}{colors.reset}"
-
-    # Output: [Model] directory | branch [changes] | XXk free (XX%) [+delta] [AC] [session_id]
-    base = f"{colors.dim}[{model}]{colors.reset} {colors.blue}{dir_name}{colors.reset}"
-    max_width = get_terminal_width()
-    parts = [base, git_info, context_info, delta_info, mi_info, ac_info, session_info]
-    print(fit_to_width(parts, max_width))
-
-
-if __name__ == "__main__":
-    main()

package/src/claude_statusline/core/__init__.py

@@ -1 +0,0 @@
-"""Core functionality for claude-statusline."""

package/src/claude_statusline/core/colors.py

@@ -1,124 +0,0 @@
-"""ANSI color constants and utilities."""
-
-from __future__ import annotations
-
-import re
-
-# ANSI color codes (defaults)
-BLUE = "\033[0;34m"
-MAGENTA = "\033[0;35m"
-CYAN = "\033[0;36m"
-GREEN = "\033[0;32m"
-YELLOW = "\033[0;33m"
-RED = "\033[0;31m"
-BOLD = "\033[1m"
-DIM = "\033[2m"
-RESET = "\033[0m"
-
-# Mapping from color names to ANSI codes
-COLOR_NAMES: dict[str, str] = {
-    "black": "\033[0;30m",
-    "red": "\033[0;31m",
-    "green": "\033[0;32m",
-    "yellow": "\033[0;33m",
-    "blue": "\033[0;34m",
-    "magenta": "\033[0;35m",
-    "cyan": "\033[0;36m",
-    "white": "\033[0;37m",
-    "bright_black": "\033[0;90m",
-    "bright_red": "\033[0;91m",
-    "bright_green": "\033[0;92m",
-    "bright_yellow": "\033[0;93m",
-    "bright_blue": "\033[0;94m",
-    "bright_magenta": "\033[0;95m",
-    "bright_cyan": "\033[0;96m",
-    "bright_white": "\033[0;97m",
-}
-
-_HEX_RE = re.compile(r"^#([0-9a-fA-F]{6})$")
-
-
-def parse_color(value: str) -> str | None:
-    """Parse a color value into an ANSI escape code.
-
-    Accepts:
-      - Named colors: "red", "green", "bright_cyan", etc.
-      - Hex colors: "#ff5733" (converted to 24-bit ANSI)
-
-    Returns:
-        ANSI escape code string, or None if the value is not recognized.
-    """
-    value = value.strip().lower()
-    if not value:
-        return None
-
-    # Named color
-    if value in COLOR_NAMES:
-        return COLOR_NAMES[value]
-
-    # Hex color (#rrggbb)
-    m = _HEX_RE.match(value)
-    if m:
-        hex_str = m.group(1)
-        r = int(hex_str[0:2], 16)
-        g = int(hex_str[2:4], 16)
-        b = int(hex_str[4:6], 16)
-        return f"\033[38;2;{r};{g};{b}m"
-
-    return None
-
-
-class ColorManager:
-    """Manage color output based on terminal capabilities.
-
-    Supports custom color overrides via a dict of {slot_name: ansi_code}.
-    """
-
-    def __init__(
-        self,
-        enabled: bool = True,
-        overrides: dict[str, str] | None = None,
-    ) -> None:
-        self.enabled = enabled
-        self._overrides = overrides or {}
-
-    def _get(self, slot: str, default: str) -> str:
-        if not self.enabled:
-            return ""
-        return self._overrides.get(slot, default)
-
-    @property
-    def blue(self) -> str:
-        return self._get("blue", BLUE)
-
-    @property
-    def magenta(self) -> str:
-        return self._get("magenta", MAGENTA)
-
-    @property
-    def cyan(self) -> str:
-        return self._get("cyan", CYAN)
-
-    @property
-    def green(self) -> str:
-        return self._get("green", GREEN)
-
-    @property
-    def yellow(self) -> str:
-        return self._get("yellow", YELLOW)
-
-    @property
-    def red(self) -> str:
-        return self._get("red", RED)
-
-    @property
-    def bold(self) -> str:
-        return BOLD if self.enabled else ""
-
-    @property
-    def dim(self) -> str:
-        return DIM if self.enabled else ""
-
-    @property
-    def reset(self) -> str:
-        return RESET if self.enabled else ""