cc-context-stats 1.8.0 → 1.8.2

package/src/claude_statusline/formatters/tokens.py

@@ -1,70 +0,0 @@
-"""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

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

package/src/claude_statusline/graphs/intelligence.py

@@ -1,162 +0,0 @@
-"""Model Intelligence (MI) score computation.
-
-Estimates answer quality based on context utilization, cache efficiency,
-and output productivity. Inspired by the Michelangelo paper
-(arXiv:2409.12640, Google DeepMind, Sep 2024).
-"""
-
-from __future__ import annotations
-
-from dataclasses import dataclass
-
-from claude_statusline.core.state import StateEntry
-
-# Hardcoded constants — not configurable, to minimize cross-implementation sync burden
-MI_WEIGHT_CPS = 0.60
-MI_WEIGHT_ES = 0.25
-MI_WEIGHT_PS = 0.15
-MI_GREEN_THRESHOLD = 0.65
-MI_YELLOW_THRESHOLD = 0.35
-MI_PRODUCTIVITY_TARGET = 0.2
-
-
-@dataclass
-class IntelligenceConfig:
-    """Configuration for MI computation."""
-
-    beta: float = 1.5
-
-
-@dataclass
-class IntelligenceScore:
-    """MI score with sub-components."""
-
-    cps: float
-    es: float
-    ps: float
-    mi: float
-    utilization: float
-
-
-def calculate_context_pressure(utilization: float, beta: float = 1.5) -> float:
-    """Calculate Context Pressure Score (CPS).
-
-    CPS = max(0, 1 - u^beta) where u is utilization ratio [0, 1+].
-
-    Args:
-        utilization: Context utilization ratio (current_used / context_window_size)
-        beta: Curve shape parameter (default 1.5)
-
-    Returns:
-        CPS value in [0, 1]
-    """
-    if utilization <= 0:
-        return 1.0
-    return max(0.0, 1.0 - utilization**beta)
-
-
-def calculate_efficiency(entry: StateEntry) -> float:
-    """Calculate Efficiency Score (ES).
-
-    ES = 0.3 + 0.7 * cache_hit_ratio, where cache_hit_ratio = cache_read / total_context.
-
-    Args:
-        entry: Current state entry
-
-    Returns:
-        ES value in [0.3, 1.0]
-    """
-    total_context = entry.current_used_tokens
-    if total_context == 0:
-        return 1.0
-    cache_hit_ratio = entry.cache_read / total_context
-    return 0.3 + 0.7 * cache_hit_ratio
-
-
-def calculate_productivity(
-    current: StateEntry, previous: StateEntry | None
-) -> float:
-    """Calculate Productivity Score (PS).
-
-    Uses consecutive entry diffs for delta_lines and delta_output_tokens.
-
-    Args:
-        current: Current state entry
-        previous: Previous state entry, or None
-
-    Returns:
-        PS value in [0.2, 1.0], or 0.5 if no previous entry
-    """
-    if previous is None:
-        return 0.5
-
-    delta_lines_added = current.lines_added - previous.lines_added
-    delta_lines_removed = current.lines_removed - previous.lines_removed
-    delta_output_tokens = current.total_output_tokens - previous.total_output_tokens
-
-    if delta_output_tokens <= 0:
-        return 0.5
-
-    delta_lines = delta_lines_added + delta_lines_removed
-    ratio = delta_lines / delta_output_tokens
-    normalized = min(1.0, ratio / MI_PRODUCTIVITY_TARGET)
-    return 0.2 + 0.8 * normalized
-
-
-def calculate_intelligence(
-    current: StateEntry,
-    previous: StateEntry | None,
-    context_window_size: int,
-    beta: float = 1.5,
-) -> IntelligenceScore:
-    """Calculate composite Model Intelligence score.
-
-    Args:
-        current: Current state entry
-        previous: Previous state entry (for productivity delta)
-        context_window_size: Total context window size in tokens
-        beta: CPS curve shape parameter
-
-    Returns:
-        IntelligenceScore with all sub-scores and composite MI
-    """
-    # Guard clause: unknown context window
-    if context_window_size == 0:
-        return IntelligenceScore(cps=1.0, es=1.0, ps=0.5, mi=1.0, utilization=0.0)
-
-    utilization = current.current_used_tokens / context_window_size
-    cps = calculate_context_pressure(utilization, beta)
-    es = calculate_efficiency(current)
-    ps = calculate_productivity(current, previous)
-
-    mi = MI_WEIGHT_CPS * cps + MI_WEIGHT_ES * es + MI_WEIGHT_PS * ps
-
-    return IntelligenceScore(cps=cps, es=es, ps=ps, mi=mi, utilization=utilization)
-
-
-def get_mi_color(mi: float) -> str:
-    """Get color name for MI score.
-
-    Args:
-        mi: MI score value
-
-    Returns:
-        Color name: "green", "yellow", or "red"
-    """
-    if mi > MI_GREEN_THRESHOLD:
-        return "green"
-    if mi > MI_YELLOW_THRESHOLD:
-        return "yellow"
-    return "red"
-
-
-def format_mi_score(mi: float) -> str:
-    """Format MI score for display.
-
-    Args:
-        mi: MI score value
-
-    Returns:
-        Formatted string like "0.82"
-    """
-    return f"{mi:.2f}"

package/src/claude_statusline/graphs/renderer.py

@@ -1,401 +0,0 @@
-"""ASCII graph rendering engine."""
-
-from __future__ import annotations
-
-import shutil
-from collections.abc import Callable
-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_deltas, 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
-        self._output_lines: list[str] | None = None
-
-    def begin_buffering(self) -> None:
-        """Start buffering output instead of printing directly."""
-        self._output_lines = []
-
-    def get_buffer(self) -> str:
-        """Return buffered output as a single string and stop buffering."""
-        if self._output_lines is None:
-            return ""
-        result = "\n".join(self._output_lines)
-        self._output_lines = None
-        return result
-
-    def _emit(self, line: str = "") -> None:
-        """Emit a line of output. Buffers if buffering is active, otherwise prints."""
-        if self._output_lines is not None:
-            self._output_lines.append(line)
-        else:
-            print(line)
-
-    def render_timeseries(
-        self,
-        data: list[int],
-        timestamps: list[int],
-        title: str,
-        color: str,
-        label_fn: Callable[[int], str] | None = None,
-    ) -> 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
-            label_fn: Optional function to format Y-axis labels. If None, uses format_tokens().
-        """
-        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
-
-        fmt = label_fn if label_fn else lambda v: format_tokens(v, self.token_detail)
-
-        # Print title and stats
-        self._emit()
-        self._emit(f"{self.colors.bold}{title}{self.colors.reset}")
-        self._emit(
-            f"{self.colors.dim}Max: {fmt(max_val)}  "
-            f"Min: {fmt(min_val)}  "
-            f"Points: {n}{self.colors.reset}"
-        )
-        self._emit()
-
-        # 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 = fmt(val)
-            else:
-                label = ""
-
-            row_data = grid[r] if r < len(grid) else " " * width
-            self._emit(
-                f"{label:>10} {self.colors.dim}│{self.colors.reset}"
-                f"{color}{row_data}{self.colors.reset}"
-            )
-
-        # X-axis
-        self._emit(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
-            self._emit(
-                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],
-        mi_score: object | None = None,  # IntelligenceScore
-    ) -> None:
-        """Render summary statistics.
-
-        Args:
-            entries: List of StateEntry objects
-            deltas: List of token deltas
-            mi_score: Optional IntelligenceScore for MI display
-        """
-        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"
-
-        self._emit()
-        self._emit(f"{self.colors.bold}Session Summary{self.colors.reset}")
-        line_width = self.dimensions.graph_width + 11
-        self._emit(f"{self.colors.dim}{'-' * line_width}{self.colors.reset}")
-
-        # Context remaining (before status)
-        if last.context_window_size > 0:
-            self._emit(
-                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:
-            self._emit(
-                f"  {status_color}{self.colors.bold}>>> {status_text.upper()} <<<{self.colors.reset} "
-                f"{self.colors.dim}({status_hint}){self.colors.reset}"
-            )
-
-        # Model Intelligence score
-        if mi_score is not None:
-            from claude_statusline.graphs.intelligence import (
-                format_mi_score,
-                get_mi_color,
-            )
-
-            mi_color_name = get_mi_color(mi_score.mi)
-            mi_color = getattr(self.colors, mi_color_name)
-            if mi_score.mi > 0.65:
-                mi_hint = "Model is operating well"
-            elif mi_score.mi > 0.35:
-                mi_hint = "Context pressure is degrading answer quality"
-            else:
-                mi_hint = "Severely degraded, consider new session"
-            self._emit(
-                f"  {mi_color}{'Model Intelligence:':<20}{self.colors.reset} "
-                f"{format_mi_score(mi_score.mi)}  "
-                f"{self.colors.dim}({mi_hint}){self.colors.reset}"
-            )
-            self._emit(
-                f"  {self.colors.dim}  CPS: {mi_score.cps:.2f}  "
-                f"ES: {mi_score.es:.2f}  "
-                f"PS: {mi_score.ps:.2f}{self.colors.reset}"
-            )
-
-        if last.context_window_size > 0:
-            self._emit()
-
-        # Session details (ordered: Last Growth, I/O, Lines, Cost, Model, Duration)
-        if deltas:
-            current_growth = deltas[-1]
-            self._emit(
-                f"  {self.colors.cyan}{'Last Growth:':<20}{self.colors.reset} "
-                f"+{format_tokens(current_growth, self.token_detail)}"
-            )
-        self._emit(
-            f"  {self.colors.blue}{'Input Tokens:':<20}{self.colors.reset} "
-            f"{format_tokens(last.current_input_tokens, self.token_detail)}"
-        )
-        self._emit(
-            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:
-            self._emit(
-                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:
-            self._emit(
-                f"  {self.colors.yellow}{'Total Cost:':<20}{self.colors.reset} ${last.cost_usd:.4f}"
-            )
-        if last.model_id:
-            self._emit(f"  {self.colors.dim}{'Model:':<20}{self.colors.reset} {last.model_id}")
-        self._emit(
-            f"  {self.colors.cyan}{'Session Duration:':<20}{self.colors.reset} "
-            f"{format_duration(duration)}"
-        )
-        self._emit()
-
-    def render_footer(self, version: str = "1.6.1", commit_hash: str = "dev") -> None:
-        """Render the footer with version info.
-
-        Args:
-            version: Package version
-            commit_hash: Git commit hash
-        """
-        self._emit(
-            f"{self.colors.dim}Powered by {self.colors.cyan}cc-context-stats"
-            f"{self.colors.dim} v{version}-{commit_hash} - "
-            f"https://github.com/luongnv89/cc-context-stats{self.colors.reset}"
-        )
-        self._emit()