ccburn 0.2.1__tar.gz → 0.3.0__tar.gz

{ccburn-0.2.1/src/ccburn.egg-info → ccburn-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ccburn
-Version: 0.2.1
+Version: 0.3.0
 Summary: Terminal-based Claude Code usage limit visualizer with real-time burn-up charts
 Author: JuanjoFuchs
 License-Expression: MIT
@@ -45,7 +45,10 @@ Dynamic: license-file
 [![PyPI](https://img.shields.io/pypi/v/ccburn)](https://pypi.org/project/ccburn/)
 [![Python](https://img.shields.io/pypi/pyversions/ccburn)](https://pypi.org/project/ccburn/)
 [![GitHub Release](https://img.shields.io/github/v/release/JuanjoFuchs/ccburn)](https://github.com/JuanjoFuchs/ccburn/releases)
-[![WinGet](https://img.shields.io/badge/WinGet-pending-yellow)](https://github.com/microsoft/winget-pkgs/pulls?q=is%3Apr+ccburn)
+[![WinGet](https://img.shields.io/winget/v/JuanjoFuchs.ccburn)](https://winstall.app/apps/JuanjoFuchs.ccburn)
+[![npm downloads](https://img.shields.io/npm/dt/ccburn?label=npm%20downloads)](https://www.npmjs.com/package/ccburn)
+[![PyPI downloads](https://img.shields.io/pepy/dt/ccburn?label=pypi%20downloads)](https://pepy.tech/project/ccburn)
+[![GitHub downloads](https://img.shields.io/github/downloads/JuanjoFuchs/ccburn/total?label=github%20downloads)](https://github.com/JuanjoFuchs/ccburn/releases)
 [![License](https://img.shields.io/github/license/JuanjoFuchs/ccburn)](LICENSE)
 
 <p align="center">
@@ -73,7 +76,7 @@ TUI and CLI for Claude Code usage limits — burn-up charts, compact mode for st
 
 Run `claude` and login first to refresh credentials.
 
-### WinGet (*pending approval*)
+### WinGet (Windows)
 
 ```powershell
 winget install JuanjoFuchs.ccburn

{ccburn-0.2.1 → ccburn-0.3.0}/README.md

@@ -6,7 +6,10 @@
 [![PyPI](https://img.shields.io/pypi/v/ccburn)](https://pypi.org/project/ccburn/)
 [![Python](https://img.shields.io/pypi/pyversions/ccburn)](https://pypi.org/project/ccburn/)
 [![GitHub Release](https://img.shields.io/github/v/release/JuanjoFuchs/ccburn)](https://github.com/JuanjoFuchs/ccburn/releases)
-[![WinGet](https://img.shields.io/badge/WinGet-pending-yellow)](https://github.com/microsoft/winget-pkgs/pulls?q=is%3Apr+ccburn)
+[![WinGet](https://img.shields.io/winget/v/JuanjoFuchs.ccburn)](https://winstall.app/apps/JuanjoFuchs.ccburn)
+[![npm downloads](https://img.shields.io/npm/dt/ccburn?label=npm%20downloads)](https://www.npmjs.com/package/ccburn)
+[![PyPI downloads](https://img.shields.io/pepy/dt/ccburn?label=pypi%20downloads)](https://pepy.tech/project/ccburn)
+[![GitHub downloads](https://img.shields.io/github/downloads/JuanjoFuchs/ccburn/total?label=github%20downloads)](https://github.com/JuanjoFuchs/ccburn/releases)
 [![License](https://img.shields.io/github/license/JuanjoFuchs/ccburn)](LICENSE)
 
 <p align="center">
@@ -34,7 +37,7 @@ TUI and CLI for Claude Code usage limits — burn-up charts, compact mode for st
 
 Run `claude` and login first to refresh credentials.
 
-### WinGet (*pending approval*)
+### WinGet (Windows)
 
 ```powershell
 winget install JuanjoFuchs.ccburn

{ccburn-0.2.1 → ccburn-0.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ccburn"
-version = "0.2.1"
+version = "0.3.0"
 description = "Terminal-based Claude Code usage limit visualizer with real-time burn-up charts"
 authors = [{name = "JuanjoFuchs"}]
 readme = "README.md"

{ccburn-0.2.1 → ccburn-0.3.0}/src/ccburn/app.py

@@ -1,5 +1,6 @@
 """Main application class for ccburn."""
 
+import os
 import signal
 import threading
 import time
@@ -34,7 +35,7 @@ class CCBurnApp:
         self,
         limit_type: LimitType = LimitType.SESSION,
         interval: int = 5,
-        since: datetime | None = None,
+        since_duration: timedelta | None = None,
         json_output: bool = False,
         once: bool = False,
         compact: bool = False,
@@ -45,7 +46,7 @@ class CCBurnApp:
         Args:
             limit_type: Which limit to display
             interval: Refresh interval in seconds
-            since: Only show data since this time (zoom view)
+            since_duration: Time window duration for zoom view (sliding window)
             json_output: Output JSON instead of TUI
             once: Print once and exit
             compact: Single-line output for status bars
@@ -53,13 +54,18 @@ class CCBurnApp:
         """
         self.limit_type = limit_type
         self.interval = interval
-        self.since = since
+        self.since_duration = since_duration
         self.json_output = json_output
         self.once = once
         self.compact = compact
         self.debug = debug
 
-        self.console = Console()
+        # Disable legacy_windows mode for modern terminals to prevent Unicode issues
+        # Rich may incorrectly detect legacy mode even in Windows Terminal
+        use_legacy = None  # Auto-detect by default
+        if os.environ.get("WT_SESSION"):  # Windows Terminal
+            use_legacy = False
+        self.console = Console(legacy_windows=use_legacy)
         self.client = UsageClient()
         self.history: HistoryDB | None = None
         self.layout = BurnupLayout(self.console)
@@ -71,6 +77,16 @@ class CCBurnApp:
         self.last_error: str | None = None
         self.snapshots: list[UsageSnapshot] = []
 
+    def _get_since_datetime(self) -> datetime | None:
+        """Calculate the since datetime based on current time and duration.
+
+        Returns:
+            datetime for filtering, or None if no duration set
+        """
+        if self.since_duration is None:
+            return None
+        return datetime.now(timezone.utc) - self.since_duration
+
     def _setup_signal_handlers(self) -> None:
         """Setup signal handlers for graceful shutdown."""
 
@@ -93,10 +109,10 @@ class CCBurnApp:
                 self.history = HistoryDB()
                 # Prune old data on startup
                 self.history.prune_old_data()
-                # Load existing snapshots
+                # Load existing snapshots (use current since datetime)
                 self.snapshots = self.history.get_snapshots_for_limit(
                     self.limit_type,
-                    since=self.since,
+                    since=self._get_since_datetime(),
                 )
             except Exception as e:
                 # Fall back to in-memory if SQLite fails
@@ -134,10 +150,10 @@ class CCBurnApp:
                         self.last_snapshot = snapshot
                         self.last_fetch_time = snapshot.timestamp
                         self.last_error = None
-                        # Reload snapshots from database
+                        # Reload snapshots from database (use current since datetime)
                         self.snapshots = self.history.get_snapshots_for_limit(
                             self.limit_type,
-                            since=self.since,
+                            since=self._get_since_datetime(),
                         )
                         return True
 
@@ -154,9 +170,10 @@ class CCBurnApp:
             # Add to local list
             self.snapshots.append(snapshot)
 
-            # Keep only relevant snapshots (based on since or window)
-            if self.since:
-                self.snapshots = [s for s in self.snapshots if s.timestamp >= self.since]
+            # Keep only relevant snapshots (based on since_duration or window)
+            since_dt = self._get_since_datetime()
+            if since_dt:
+                self.snapshots = [s for s in self.snapshots if s.timestamp >= since_dt]
             else:
                 # Keep last 24 hours of data for calculations
                 cutoff = datetime.now(timezone.utc) - timedelta(hours=24)
@@ -276,7 +293,7 @@ class CCBurnApp:
             limit_data,
             self.snapshots,
             error=self.last_error,
-            since=self.since,
+            since_duration=self.since_duration,
         )
         self.console.print(layout)
 
@@ -307,7 +324,7 @@ class CCBurnApp:
                 limit_data,
                 self.snapshots,
                 error=self.last_error,
-                since=self.since,
+                since_duration=self.since_duration,
             )
 
             # Set initial window title
@@ -367,7 +384,7 @@ class CCBurnApp:
                         self.snapshots,
                         error=self.last_error,
                         stale_since=stale_since,
-                        since=self.since,
+                        since_duration=self.since_duration,
                     )
                     live.update(updated_layout)
                     self._update_window_title()
@@ -416,7 +433,7 @@ class CCBurnApp:
                     "status": metrics.status,
                 }
 
-        # Add burn rate for selected limit
+        # Add burn rate and projection for selected limit
         limit_data = self.last_snapshot.get_limit(self.limit_type)
         if limit_data:
             metrics = calculate_burn_metrics(limit_data, self.snapshots)
@@ -428,6 +445,39 @@ class CCBurnApp:
             }
             output["recommendation"] = metrics.recommendation
 
+            # Add projection data
+            if metrics.percent_per_hour > 0:
+                current_pct = limit_data.utilization * 100
+                remaining_pct = 100.0 - current_pct
+                hours_to_100 = remaining_pct / metrics.percent_per_hour
+
+                now = datetime.now(timezone.utc)
+                remaining_window_hours = (limit_data.resets_at - now).total_seconds() / 3600
+
+                if hours_to_100 <= remaining_window_hours:
+                    # Will hit 100% before window ends
+                    projected_end_pct = 100.0
+                    hits_100 = True
+                    status = "warning"
+                else:
+                    # Won't hit 100%
+                    projected_end_pct = current_pct + (metrics.percent_per_hour * remaining_window_hours)
+                    hits_100 = False
+                    status = "safe"
+
+                output["projection"] = {
+                    "available": True,
+                    "projected_end_pct": round(min(projected_end_pct, 100.0), 1),
+                    "hits_100": hits_100,
+                    "hours_to_100": round(hours_to_100, 1) if hits_100 else None,
+                    "status": status,
+                }
+            else:
+                output["projection"] = {
+                    "available": False,
+                    "reason": "insufficient_data" if metrics.percent_per_hour == 0 else "usage_decreasing",
+                }
+
         return output
 
     def stop(self) -> None:

{ccburn-0.2.1 → ccburn-0.3.0}/src/ccburn/cli.py

@@ -1,7 +1,7 @@
 """CLI command definitions for ccburn."""
 
 import re
-from datetime import datetime, timedelta, timezone
+from datetime import timedelta
 
 import typer
 from rich.console import Console
@@ -132,12 +132,11 @@ def run_app(
     except ImportError:
         from ccburn.app import CCBurnApp
 
-    # Calculate since datetime if provided
-    since_dt = None
+    # Parse since duration if provided
+    since_duration = None
     if since:
         try:
-            since_delta = parse_duration(since)
-            since_dt = datetime.now(timezone.utc) - since_delta
+            since_duration = parse_duration(since)
         except typer.BadParameter as e:
             typer.echo(f"Error: {e}", err=True)
             raise typer.Exit(1) from None
@@ -145,7 +144,7 @@ def run_app(
     app = CCBurnApp(
         limit_type=limit_type,
         interval=interval,
-        since=since_dt,
+        since_duration=since_duration,
         json_output=json_output,
         once=once,
         compact=compact,

{ccburn-0.2.1 → ccburn-0.3.0}/src/ccburn/display/chart.py

@@ -9,10 +9,10 @@ from rich.console import Console, ConsoleOptions, Group, RenderableType
 from rich.jupyter import JupyterMixin
 
 try:
-    from ..data.models import LimitData, UsageSnapshot
+    from ..data.models import BurnMetrics, LimitData, UsageSnapshot
     from ..utils.formatting import get_utilization_color
 except ImportError:
-    from ccburn.data.models import LimitData, UsageSnapshot
+    from ccburn.data.models import BurnMetrics, LimitData, UsageSnapshot
     from ccburn.utils.formatting import get_utilization_color
 
 
@@ -23,21 +23,24 @@ class BurnupChart(JupyterMixin):
         self,
         limit_data: LimitData | None,
         snapshots: list[UsageSnapshot],
-        since: datetime | None = None,
+        since_duration: timedelta | None = None,
         explicit_height: int | None = None,
+        burn_metrics: BurnMetrics | None = None,
     ):
         """Initialize the burnup chart.
 
         Args:
             limit_data: Current limit data (for window boundaries)
             snapshots: Historical snapshots to plot
-            since: Only show data since this time (zoom view)
+            since_duration: Duration for zoom view (sliding window, e.g., last 1h)
             explicit_height: Override chart height
+            burn_metrics: Burn rate metrics for projection line
         """
         self.limit_data = limit_data
         self.snapshots = snapshots
-        self.since = since
+        self.since_duration = since_duration
         self.explicit_height = explicit_height
+        self.burn_metrics = burn_metrics
         self.decoder = AnsiDecoder()
 
     def __rich_console__(
@@ -86,12 +89,14 @@ class BurnupChart(JupyterMixin):
         window_end = self.limit_data.resets_at
         now = datetime.now(timezone.utc)
 
-        # Display window (may be zoomed with --since)
+        # Display window (may be zoomed with --since as a sliding window)
         display_start = original_window_start
         display_end = window_end
-        if self.since:
-            display_start = max(original_window_start, self.since)
-            display_end = now  # When zoomed, show until now, not session end
+        if self.since_duration:
+            # Sliding window: always show the last N duration (e.g., last 1h)
+            # Both start and end move forward with time
+            display_start = max(original_window_start, now - self.since_duration)
+            display_end = now
 
         # Filter snapshots to display window
         relevant_snapshots = [
@@ -160,11 +165,46 @@ class BurnupChart(JupyterMixin):
                     label="Usage",
                 )
 
+        # Plot projection line if we have positive burn rate (not on zoomed views)
+        hits_100_hours = None  # Track when projection hits 100% for vertical marker
+        if self.burn_metrics and self.burn_metrics.percent_per_hour > 0 and not self.since_duration:
+            current_pct = self.limit_data.utilization * 100
+            now_hours = to_hours(now)
+
+            # Only draw projection if not already at or above 100%
+            if current_pct < 100.0:
+                # Calculate time to hit 100%
+                remaining_pct = 100.0 - current_pct
+                hours_to_100 = remaining_pct / self.burn_metrics.percent_per_hour
+
+                # End point: either 100% or window end, whichever comes first
+                remaining_window_hours = (display_end - now).total_seconds() / 3600
+
+                if hours_to_100 <= remaining_window_hours:
+                    # Will hit 100% before window ends
+                    end_hours = now_hours + hours_to_100
+                    end_pct = 100.0
+                    proj_color = (255, 100, 0)  # Orange - warning
+                    hits_100_hours = end_hours  # Mark for vertical line
+                else:
+                    # Won't hit 100%, project to window end
+                    end_hours = now_hours + remaining_window_hours
+                    end_pct = current_pct + (self.burn_metrics.percent_per_hour * remaining_window_hours)
+                    proj_color = (100, 200, 100)  # Green - safe
+
+                plt.plot(
+                    [now_hours, end_hours],
+                    [current_pct, min(end_pct, 100.0)],
+                    color=proj_color,
+                    marker="braille",
+                    label="Projection",
+                )
+
         # Configure axes
         plt.xlim(0, display_hours)
 
         # Y-axis: dynamic when zoomed (--since), fixed 0-100 otherwise
-        if self.since and values:
+        if self.since_duration and values:
             # Calculate dynamic range from data with padding
             all_y_values = values + pace_y
             data_min = min(all_y_values)
@@ -186,7 +226,7 @@ class BurnupChart(JupyterMixin):
         # Add "now" vertical line when showing full window (not zoomed)
         # Use dotted effect by plotting points at intervals
         now_hours_for_tick = None
-        if not self.since:
+        if not self.since_duration:
             now_hours = to_hours(now)
             if 0 < now_hours < display_hours:
                 # Create dotted vertical line with points using braille marker to match other lines
@@ -196,6 +236,15 @@ class BurnupChart(JupyterMixin):
                 plt.plot(dot_x, dot_y, color=(0, 120, 255), marker="braille", label="Now")
                 now_hours_for_tick = now_hours
 
+        # Add "hits 100%" vertical line when projection exceeds budget
+        hits_100_hours_for_tick = None
+        if hits_100_hours is not None and 0 < hits_100_hours < display_hours:
+            num_dots = 20
+            dot_y = [y_min + i * (y_max - y_min) / (num_dots - 1) for i in range(num_dots)]
+            dot_x = [hits_100_hours] * num_dots
+            plt.plot(dot_x, dot_y, color=(255, 100, 0), marker="braille", label="Depleted")
+            hits_100_hours_for_tick = hits_100_hours
+
         # Enable right Y axis with same range
         plt.plot([display_hours], [y_max], marker=" ", yside="right")  # Hidden point to enable right axis
         plt.ylim(y_min, y_max, yside="right")
@@ -247,6 +296,28 @@ class BurnupChart(JupyterMixin):
             else:
                 tick_labels.append(local_now.strftime("%H:%M"))
 
+        # Add "100%" tick if showing the hits-100 line
+        if hits_100_hours_for_tick is not None:
+            min_distance = display_hours / 10  # Minimum 10% of display width apart
+            # Filter out ticks that are too close to "100%"
+            filtered = [(pos, label) for pos, label in zip(tick_positions, tick_labels, strict=True)
+                        if abs(hits_100_hours_for_tick - pos) >= min_distance]
+            tick_positions = [pos for pos, _ in filtered]
+            tick_labels = [label for _, label in filtered]
+            # Add the "100%" tick with timestamp
+            hits_100_time = display_start + timedelta(hours=hits_100_hours_for_tick)
+            local_hits_100 = hits_100_time.astimezone()
+            # Round to nearest minute
+            if local_hits_100.second >= 30:
+                local_hits_100 = local_hits_100.replace(second=0, microsecond=0) + timedelta(minutes=1)
+            else:
+                local_hits_100 = local_hits_100.replace(second=0, microsecond=0)
+            tick_positions.append(hits_100_hours_for_tick)
+            if use_date_format:
+                tick_labels.append(local_hits_100.strftime("%a %Hh"))
+            else:
+                tick_labels.append(local_hits_100.strftime("%H:%M"))
+
         plt.xticks(tick_positions, tick_labels)
 
         # No labels on axes
@@ -291,7 +362,7 @@ def create_simple_chart(
     snapshots: list[UsageSnapshot],
     width: int = 80,
     height: int = 15,
-    since: datetime | None = None,
+    since_duration: timedelta | None = None,
 ) -> str:
     """Create a simple chart string without Rich integration.
 
@@ -300,10 +371,10 @@ def create_simple_chart(
         snapshots: Historical snapshots
         width: Chart width
         height: Chart height
-        since: Only show data since this time
+        since_duration: Duration for zoom view (sliding window)
 
     Returns:
         Rendered chart string
     """
-    chart = BurnupChart(limit_data, snapshots, since=since, explicit_height=height)
+    chart = BurnupChart(limit_data, snapshots, since_duration=since_duration, explicit_height=height)
     return chart._create_chart(width, height)

{ccburn-0.2.1 → ccburn-0.3.0}/src/ccburn/display/gauges.py

@@ -1,5 +1,8 @@
 """Progress bar gauges for ccburn TUI."""
 
+import os
+import sys
+
 from rich.progress import ProgressBar
 from rich.style import Style
 from rich.table import Table
@@ -15,26 +18,76 @@ except ImportError:
     from ccburn.utils.formatting import format_reset_time, get_utilization_color
 
 
-def get_pace_emoji(utilization: float, budget_pace: float) -> str:
+_emoji_support_cache: bool | None = None
+
+
+def _supports_emoji() -> bool:
+    """Detect if the console supports emoji characters.
+
+    Result is cached to ensure consistent behavior throughout the session,
+    as Rich's Live mode may affect stdout properties during rendering.
+
+    Returns:
+        True if emoji are likely supported, False otherwise.
+    """
+    global _emoji_support_cache
+    if _emoji_support_cache is not None:
+        return _emoji_support_cache
+
+    # First, check if stdout encoding can handle emoji - this prevents crashes
+    # even in modern terminals if Python's encoding is misconfigured
+    try:
+        encoding = getattr(sys.stdout, "encoding", None) or ""
+        if encoding.lower() not in ("utf-8", "utf8"):
+            # Try to encode an emoji to test
+            "🔥".encode(encoding)
+    except (UnicodeEncodeError, LookupError):
+        # Encoding cannot handle emoji - use ASCII to prevent crashes
+        _emoji_support_cache = False
+        return False
+
+    # Encoding is OK, now check for modern terminal environments
+    # that are known to render emoji correctly
+    if os.environ.get("WT_SESSION"):  # Windows Terminal
+        _emoji_support_cache = True
+        return True
+    if os.environ.get("TERM_PROGRAM"):  # macOS Terminal, iTerm2, VS Code, etc.
+        _emoji_support_cache = True
+        return True
+    if os.environ.get("COLORTERM") == "truecolor":  # Modern terminals with truecolor
+        _emoji_support_cache = True
+        return True
+
+    # Fall back to utf-8 encoding check
+    encoding = getattr(sys.stdout, "encoding", None) or ""
+    _emoji_support_cache = encoding.lower() in ("utf-8", "utf8")
+    return _emoji_support_cache
+
+
+def get_pace_emoji(utilization: float, budget_pace: float, ascii_fallback: bool = False) -> str:
     """Get emoji indicator based on utilization vs budget pace.
 
     Args:
         utilization: Current utilization (0-1)
         budget_pace: Expected budget pace (0-1)
+        ascii_fallback: If True, use ASCII characters instead of emoji
 
     Returns:
         Emoji: 🧊 (behind), 🔥 (on pace), 🚨 (ahead)
+        ASCII: [_] (behind), [=] (on pace), [!] (ahead)
     """
+    use_ascii = ascii_fallback or not _supports_emoji()
+
     if budget_pace == 0:
-        return "🔥"
+        return "[=]" if use_ascii else "🔥"
 
     ratio = utilization / budget_pace
     if ratio < 0.85:
-        return "🧊"  # Behind pace - ice cold, under budget
+        return "[_]" if use_ascii else "🧊"  # Behind pace - ice cold, under budget
     elif ratio > 1.15:
-        return "🚨"  # Ahead of pace - alarm!
+        return "[!]" if use_ascii else "🚨"  # Ahead of pace - alarm!
     else:
-        return "🔥"  # On pace - normal burn
+        return "[=]" if use_ascii else "🔥"  # On pace - normal burn
 
 
 def create_header(limit_type: LimitType, limit_data: LimitData | None) -> Table:

{ccburn-0.2.1 → ccburn-0.3.0}/src/ccburn/display/layout.py

@@ -1,7 +1,7 @@
 """Layout manager for ccburn TUI."""
 
 import os
-from datetime import datetime, timezone
+from datetime import datetime, timedelta, timezone
 
 from rich.console import Console
 from rich.layout import Layout
@@ -68,7 +68,7 @@ class BurnupLayout:
         snapshots: list[UsageSnapshot],
         error: str | None = None,
         stale_since: datetime | None = None,
-        since: datetime | None = None,
+        since_duration: timedelta | None = None,
     ) -> Layout:
         """Update the layout with new data.
 
@@ -78,7 +78,7 @@ class BurnupLayout:
             snapshots: Historical snapshots for chart
             error: Error message to display (if any)
             stale_since: When data became stale (if using cached data)
-            since: Zoom view start time
+            since_duration: Zoom view duration (sliding window)
 
         Returns:
             Updated Rich Layout
@@ -97,14 +97,14 @@ class BurnupLayout:
         if self.should_use_compact_mode():
             return self._create_compact_layout(limit_type, width, height)
 
-        return self._create_full_layout(limit_type, width, height, since)
+        return self._create_full_layout(limit_type, width, height, since_duration)
 
     def _create_full_layout(
         self,
         limit_type: LimitType,
         width: int,
         height: int,
-        since: datetime | None = None,
+        since_duration: timedelta | None = None,
     ) -> Layout:
         """Create full TUI layout with header, gauges, and chart.
 
@@ -112,7 +112,7 @@ class BurnupLayout:
             limit_type: Which limit to display
             width: Terminal width
             height: Terminal height
-            since: Zoom view start time
+            since_duration: Zoom view duration (sliding window)
 
         Returns:
             Rich Layout
@@ -155,8 +155,9 @@ class BurnupLayout:
         chart = BurnupChart(
             self._last_limit_data,
             self._last_snapshots,
-            since=since,
+            since_duration=since_duration,
             explicit_height=chart_height,
+            burn_metrics=self._last_metrics,
         )
         chart_layout.update(chart)
 

{ccburn-0.2.1 → ccburn-0.3.0}/src/ccburn/utils/calculator.py

@@ -41,53 +41,86 @@ def calculate_budget_pace(resets_at: datetime, window_hours: float) -> float:
 def calculate_burn_rate(
     snapshots: list[UsageSnapshot],
     limit_type: LimitType,
-    window_minutes: int = 5,
+    window_start: datetime,
+    window_hours: float,
+    min_points: int = 3,
+    min_span_pct: float = 0.10,
 ) -> float:
-    """Calculate burn rate as percentage points per hour.
+    """Calculate burn rate as percentage points per hour using linear regression.
 
-    Uses simple linear calculation over recent snapshots.
+    Uses least-squares linear regression over snapshots from the current window
+    for an accurate burn rate estimate.
 
     Args:
         snapshots: List of usage snapshots (should be sorted by timestamp)
         limit_type: Which limit to calculate burn rate for
-        window_minutes: How far back to look for calculation
+        window_start: Start of the current window (from limit_data)
+        window_hours: Duration of the window in hours
+        min_points: Minimum data points required for regression (default 3)
+        min_span_pct: Minimum time span as fraction of window (default 0.10 = 10%)
 
     Returns:
         Burn rate in percentage points per hour (e.g., 12.5 means 12.5%/hour)
+        Returns 0.0 if insufficient data (no projection should be shown)
     """
     if len(snapshots) < 2:
         return 0.0
 
-    now = datetime.now(timezone.utc)
-    cutoff = now - timedelta(minutes=window_minutes)
-
-    # Filter to recent snapshots
-    recent = [s for s in snapshots if s.timestamp >= cutoff]
-
-    if len(recent) < 2:
-        # Fall back to any 2 snapshots if not enough recent ones
-        recent = snapshots[-2:] if len(snapshots) >= 2 else []
-
-    if len(recent) < 2:
+    # Use actual window start, not now - window_minutes
+    cutoff = window_start
+
+    # Filter to snapshots within window and extract (time, utilization) pairs
+    points: list[tuple[float, float]] = []  # (hours_from_start, utilization_pct)
+    first_timestamp = None
+    last_timestamp = None
+
+    for s in snapshots:
+        if s.timestamp < cutoff:
+            continue
+        limit = s.get_limit(limit_type)
+        if limit is None:
+            continue
+        if first_timestamp is None:
+            first_timestamp = s.timestamp
+        last_timestamp = s.timestamp
+        hours = (s.timestamp - first_timestamp).total_seconds() / 3600
+        points.append((hours, limit.utilization * 100))
+
+    # Need at least min_points for meaningful regression
+    if len(points) < min_points:
         return 0.0
 
-    # Get utilization for the specified limit type
-    first = recent[0]
-    last = recent[-1]
-
-    first_limit = first.get_limit(limit_type)
-    last_limit = last.get_limit(limit_type)
-
-    if first_limit is None or last_limit is None:
+    # Check that data spans at least min_span_pct of the window
+    # e.g., for 5h session at 10%, need 30 min of data
+    # e.g., for 168h weekly at 10%, need ~17 hours of data
+    if first_timestamp and last_timestamp:
+        span_hours = (last_timestamp - first_timestamp).total_seconds() / 3600
+        min_span_hours = window_hours * min_span_pct
+        if span_hours < min_span_hours:
+            return 0.0
+
+    # If we have exactly 2 points, use simple slope
+    if len(points) == 2:
+        dx = points[1][0] - points[0][0]
+        if dx <= 0:
+            return 0.0
+        return (points[1][1] - points[0][1]) / dx
+
+    # Linear regression using least squares
+    # slope = (n*Σxy - Σx*Σy) / (n*Σx² - (Σx)²)
+    n = len(points)
+    sum_x = sum(p[0] for p in points)
+    sum_y = sum(p[1] for p in points)
+    sum_xy = sum(p[0] * p[1] for p in points)
+    sum_x2 = sum(p[0] ** 2 for p in points)
+
+    denominator = n * sum_x2 - sum_x**2
+    if abs(denominator) < 1e-10:
+        # All x values are the same (no time elapsed)
         return 0.0
 
-    delta_util = (last_limit.utilization - first_limit.utilization) * 100  # Convert to %
-    delta_hours = (last.timestamp - first.timestamp).total_seconds() / 3600
-
-    if delta_hours <= 0:
-        return 0.0
-
-    return delta_util / delta_hours  # %/hour
+    slope = (n * sum_xy - sum_x * sum_y) / denominator
+    return slope  # %/hour
 
 
 def estimate_time_to_empty(current_utilization: float, burn_rate_per_hour: float) -> int | None:
@@ -177,20 +210,23 @@ def get_status(utilization: float, budget_pace: float) -> str:
 def calculate_burn_metrics(
     limit_data: LimitData,
     snapshots: list[UsageSnapshot],
-    window_minutes: int = 5,
 ) -> BurnMetrics:
     """Calculate all burn metrics for a limit.
 
     Args:
         limit_data: Current limit data
         snapshots: Historical snapshots for burn rate calculation
-        window_minutes: How far back to look for burn rate
 
     Returns:
         BurnMetrics with all calculated values
     """
     budget_pace = calculate_budget_pace(limit_data.resets_at, limit_data.window_hours)
-    burn_rate = calculate_burn_rate(snapshots, limit_data.limit_type, window_minutes)
+    burn_rate = calculate_burn_rate(
+        snapshots,
+        limit_data.limit_type,
+        window_start=limit_data.window_start,
+        window_hours=limit_data.window_hours,
+    )
     time_to_empty = estimate_time_to_empty(limit_data.utilization, burn_rate)
     trend = classify_burn_trend(burn_rate)
     status = get_status(limit_data.utilization, budget_pace)

{ccburn-0.2.1 → ccburn-0.3.0/src/ccburn.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ccburn
-Version: 0.2.1
+Version: 0.3.0
 Summary: Terminal-based Claude Code usage limit visualizer with real-time burn-up charts
 Author: JuanjoFuchs
 License-Expression: MIT
@@ -45,7 +45,10 @@ Dynamic: license-file
 [![PyPI](https://img.shields.io/pypi/v/ccburn)](https://pypi.org/project/ccburn/)
 [![Python](https://img.shields.io/pypi/pyversions/ccburn)](https://pypi.org/project/ccburn/)
 [![GitHub Release](https://img.shields.io/github/v/release/JuanjoFuchs/ccburn)](https://github.com/JuanjoFuchs/ccburn/releases)
-[![WinGet](https://img.shields.io/badge/WinGet-pending-yellow)](https://github.com/microsoft/winget-pkgs/pulls?q=is%3Apr+ccburn)
+[![WinGet](https://img.shields.io/winget/v/JuanjoFuchs.ccburn)](https://winstall.app/apps/JuanjoFuchs.ccburn)
+[![npm downloads](https://img.shields.io/npm/dt/ccburn?label=npm%20downloads)](https://www.npmjs.com/package/ccburn)
+[![PyPI downloads](https://img.shields.io/pepy/dt/ccburn?label=pypi%20downloads)](https://pepy.tech/project/ccburn)
+[![GitHub downloads](https://img.shields.io/github/downloads/JuanjoFuchs/ccburn/total?label=github%20downloads)](https://github.com/JuanjoFuchs/ccburn/releases)
 [![License](https://img.shields.io/github/license/JuanjoFuchs/ccburn)](LICENSE)
 
 <p align="center">
@@ -73,7 +76,7 @@ TUI and CLI for Claude Code usage limits — burn-up charts, compact mode for st
 
 Run `claude` and login first to refresh credentials.
 
-### WinGet (*pending approval*)
+### WinGet (Windows)
 
 ```powershell
 winget install JuanjoFuchs.ccburn

{ccburn-0.2.1 → ccburn-0.3.0}/tests/test_calculator.py

@@ -63,12 +63,15 @@ class TestCalculateBurnRate:
 
     def test_no_snapshots(self):
         """Burn rate should be 0 with no snapshots."""
-        rate = calculate_burn_rate([], LimitType.SESSION)
+        now = datetime.now(timezone.utc)
+        window_start = now - timedelta(hours=5)
+        rate = calculate_burn_rate([], LimitType.SESSION, window_start, window_hours=5)
         assert rate == 0.0
 
     def test_one_snapshot(self):
         """Burn rate should be 0 with only one snapshot."""
         now = datetime.now(timezone.utc)
+        window_start = now - timedelta(hours=3)
         snapshot = UsageSnapshot(
             timestamp=now,
             session=LimitData(
@@ -80,18 +83,25 @@ class TestCalculateBurnRate:
             weekly_sonnet=None,
             weekly_opus=None,
         )
-        rate = calculate_burn_rate([snapshot], LimitType.SESSION)
+        rate = calculate_burn_rate([snapshot], LimitType.SESSION, window_start, window_hours=5)
         assert rate == 0.0
 
     def test_increasing_usage(self, sample_snapshots):
         """Burn rate should be positive when usage is increasing."""
-        rate = calculate_burn_rate(sample_snapshots, LimitType.SESSION, window_minutes=10)
+        # sample_snapshots are from 2026-01-08 14:00:00 to 14:04:30 (4.5 min span)
+        # Window starts before the first snapshot
+        # Use 30-minute window so 4.5 min span > 10% minimum (3 min)
+        window_start = datetime(2026, 1, 8, 13, 55, 0, tzinfo=timezone.utc)
+        rate = calculate_burn_rate(
+            sample_snapshots, LimitType.SESSION, window_start, window_hours=0.5
+        )
         # With 10% increase over 4.5 minutes, rate should be ~133%/hour
         assert rate > 0
 
     def test_constant_usage(self):
         """Burn rate should be 0 when usage is constant."""
         now = datetime.now(timezone.utc)
+        window_start = now - timedelta(hours=1)
         snapshots = []
         for i in range(5):
             ts = now - timedelta(minutes=i)
@@ -109,7 +119,7 @@ class TestCalculateBurnRate:
             snapshots.append(snapshot)
 
         snapshots.sort(key=lambda s: s.timestamp)
-        rate = calculate_burn_rate(snapshots, LimitType.SESSION, window_minutes=10)
+        rate = calculate_burn_rate(snapshots, LimitType.SESSION, window_start, window_hours=5)
         assert rate == pytest.approx(0.0, abs=0.1)
 
 

{ccburn-0.2.1 → ccburn-0.3.0}/tests/test_cli.py

@@ -127,7 +127,9 @@ class TestCLI:
 
     @patch("ccburn.app.CCBurnApp")
     def test_since_flag(self, mock_app_class):
-        """Test --since flag sets time window."""
+        """Test --since flag sets time window as sliding duration."""
+        from datetime import timedelta
+
         mock_app = MagicMock()
         mock_app.run.return_value = 0
         mock_app_class.return_value = mock_app
@@ -136,4 +138,4 @@ class TestCLI:
 
         mock_app_class.assert_called_once()
         call_kwargs = mock_app_class.call_args.kwargs
-        assert call_kwargs["since"] is not None  # datetime object
+        assert call_kwargs["since_duration"] == timedelta(hours=2)  # timedelta for sliding window