ccburn 0.2.2__py3-none-any.whl → 0.3.1__py3-none-any.whl

ccburn/app.py

@@ -1,8 +1,8 @@
 """Main application class for ccburn."""
 
+import os
 import signal
 import threading
-import time
 from datetime import datetime, timedelta, timezone
 from typing import Any
 
@@ -34,7 +34,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 +45,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,24 +53,40 @@ 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)
 
         # State
-        self.running = threading.Event()
+        self.running = True
+        self._stop_event = threading.Event()  # For interruptible sleep
         self.last_snapshot: UsageSnapshot | None = None
         self.last_fetch_time: datetime | None = None
         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)
@@ -180,18 +197,6 @@ class CCBurnApp:
             self.last_error = f"Unexpected error: {e}"
             return False
 
-    def _should_refresh(self) -> bool:
-        """Check if we should fetch new data.
-
-        Returns:
-            True if it's time to refresh
-        """
-        if self.last_fetch_time is None:
-            return True
-
-        elapsed = (datetime.now(timezone.utc) - self.last_fetch_time).total_seconds()
-        return elapsed >= self.interval
-
     def run(self) -> int:
         """Run the application.
 
@@ -276,7 +281,7 @@ class CCBurnApp:
             limit_data,
             self.snapshots,
             error=self.last_error,
-            since=self.since,
+            since_duration=self.since_duration,
         )
         self.console.print(layout)
 
@@ -294,7 +299,7 @@ class CCBurnApp:
             Exit code
         """
         self._setup_signal_handlers()
-        self.running.set()
+        self.running = True
 
         try:
             # Create initial display
@@ -307,7 +312,7 @@ class CCBurnApp:
                 limit_data,
                 self.snapshots,
                 error=self.last_error,
-                since=self.since,
+                since_duration=self.since_duration,
             )
 
             # Set initial window title
@@ -316,7 +321,7 @@ class CCBurnApp:
             with Live(
                 initial_layout,
                 console=self.console,
-                refresh_per_second=1,
+                auto_refresh=False,  # Manual refresh only - saves CPU
                 transient=False,
                 screen=True,
                 vertical_overflow="visible",
@@ -341,18 +346,14 @@ class CCBurnApp:
         Args:
             live: Rich Live instance
         """
-        last_update = 0.0
-
-        while self.running.is_set():
+        while self.running:
             try:
-                current_time = time.time()
-
-                # Check if we should refresh data
-                if self._should_refresh():
-                    self._fetch_and_update()
+                # Fetch new data
+                data_changed = self._fetch_and_update()
 
-                # Update display
-                if current_time - last_update >= 1.0:  # Update display every second
+                # Only re-render layout when data actually changes
+                # This avoids expensive chart re-rendering
+                if data_changed:
                     limit_data = None
                     if self.last_snapshot:
                         limit_data = self.last_snapshot.get_limit(self.limit_type)
@@ -367,18 +368,19 @@ class CCBurnApp:
                         self.snapshots,
                         error=self.last_error,
                         stale_since=stale_since,
-                        since=self.since,
+                        since_duration=self.since_duration,
                     )
                     live.update(updated_layout)
+                    live.refresh()  # Manual refresh since auto_refresh=False
                     self._update_window_title()
-                    last_update = current_time
 
-                # Small sleep to prevent busy waiting
-                time.sleep(0.05)
+                # Sleep until next refresh interval
+                # Use Event.wait() for interruptible sleep on shutdown
+                self._stop_event.wait(timeout=self.interval)
 
             except Exception:
                 # Log but continue
-                time.sleep(0.5)
+                self._stop_event.wait(timeout=self.interval)
 
     def _create_json_output(self) -> dict:
         """Create JSON output structure.
@@ -416,7 +418,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,11 +430,45 @@ 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:
         """Stop the application."""
-        self.running.clear()
+        self.running = False
+        self._stop_event.set()  # Wake up from sleep immediately
 
     def _update_window_title(self) -> None:
         """Update terminal window title with current status."""

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/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/display/gauges.py

@@ -1,5 +1,6 @@
 """Progress bar gauges for ccburn TUI."""
 
+import os
 import sys
 
 from rich.progress import ProgressBar
@@ -17,23 +18,51 @@ except ImportError:
     from ccburn.utils.formatting import format_reset_time, get_utilization_color
 
 
+_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.
     """
-    # Check if stdout encoding supports emoji
+    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() in ("utf-8", "utf8"):
-            return True
-        # Try to encode an emoji to test
-        "🔥".encode(encoding)
-        return True
+        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.

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/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.2.dist-info → ccburn-0.3.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ccburn
-Version: 0.2.2
+Version: 0.3.1
 Summary: Terminal-based Claude Code usage limit visualizer with real-time burn-up charts
 Author: JuanjoFuchs
 License-Expression: MIT
@@ -45,7 +45,7 @@ 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)
@@ -76,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.2.dist-info → ccburn-0.3.1.dist-info}/RECORD

@@ -1,6 +1,6 @@
 ccburn/__init__.py,sha256=u8tlHJ2bTam19CROn2nufmcfCONN9BwlRLY-8AOu8Os,191
-ccburn/app.py,sha256=FcVHLbnygKbMTGIFZRN5jS_Pve8VdKImfLi2KsDuEoU,15510
-ccburn/cli.py,sha256=5qYYmOWcUXNYEdK-E3DBixfWQK4wKIQs6FPvTrIfOVI,7184
+ccburn/app.py,sha256=IvIFOX10AFD103P5XiIenkEB2clAq2o3XJR6lceMVhE,17775
+ccburn/cli.py,sha256=dvh6V8I1TQlqbCv4-5j3ANRdKpoQKPHgA2QrBZUSkJY,7120
 ccburn/main.py,sha256=TqWLl9xxOtbpTQr-ObomzSLG3jNec2GZ6RKEQYYdGLg,2474
 ccburn/data/__init__.py,sha256=ZczEZwodQ-MMO5F7fVNsyIpUCRY8Ya9W4pwdOOJWxm4,803
 ccburn/data/credentials.py,sha256=wDiiTkZZDBjnYspvtWJ_52xXdTdIgBndLlfFMi-peZ8,5228
@@ -8,15 +8,15 @@ ccburn/data/history.py,sha256=ouBxrXpMp_eTs0kba1Bg55TI6bsBSMToJ32tH1wNHQI,12879
 ccburn/data/models.py,sha256=Sd2T36gH6OaNHl9zRlnnQXI-ziBA8Gl6rPYQIzmr7G4,5403
 ccburn/data/usage_client.py,sha256=_dGwmI5vYPk4S-HUe2_fnTwSuAfTPaOFff7mKPFnhps,4570
 ccburn/display/__init__.py,sha256=aL7TV53kU5oxlIwJ8M17stG2aC6UeGB-pj2u5BOpegs,495
-ccburn/display/chart.py,sha256=HGDcMqaqyNtlQzV-d-gUOStq8qjpVt4EYvCIU6BTAx8,11983
-ccburn/display/gauges.py,sha256=fEFsqPNrbME3isX41f56NZRLLoF2a3ll6_tfU8G0lFA,9440
-ccburn/display/layout.py,sha256=UndPxyh32jWGdDgOZCvedz06WcKxYMSchLwpOkkXQKo,8093
+ccburn/display/chart.py,sha256=7Rg9KeeeDjr8jwvEhHbmBYmZ0Wj3N1ijfzsQy6u6kqA,15917
+ccburn/display/gauges.py,sha256=qPjFmTJd3RcwMfpmONFHByno5ByDPaVpvDttHnfct1E,10628
+ccburn/display/layout.py,sha256=DlgmH3G2RbpyYfWYD6YP1IlohYmhWBSiqjM7Y7fto-U,8244
 ccburn/utils/__init__.py,sha256=N6EzUX9hUJkuga_l9Ci3of1CWNtQgpNmMmNyY2DgYrg,1119
-ccburn/utils/calculator.py,sha256=QcFm5X-VWZzucHdInEjjqKV5oZaNsdpMgl8oKvHAQYc,6174
+ccburn/utils/calculator.py,sha256=m-XATeOqgD5Z4ZranuI7QSlSb4pnW43_rtaJSF2Te6Q,7706
 ccburn/utils/formatting.py,sha256=MEVIohBmvSur0hcc67oyYRDooiUMf0rPa4LO1fc2Ud4,4174
-ccburn-0.2.2.dist-info/licenses/LICENSE,sha256=Qf2mqNi2qJ35JytfoTdR1SgYhZ2Mt4Ohcf-tu_MuYC0,1068
-ccburn-0.2.2.dist-info/METADATA,sha256=HnLVSePIkdJpyn66BIB7lj-TfyOmlBev_10-1yvsjJI,7373
-ccburn-0.2.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-ccburn-0.2.2.dist-info/entry_points.txt,sha256=GfFQ5VusMR8RJ9meygqWjaErdmYsf_arbILzf64WjLU,43
-ccburn-0.2.2.dist-info/top_level.txt,sha256=SM8TwGQZqQKKIQObVWQkfpA0OI4gRut7bPl-iM3g5RI,7
-ccburn-0.2.2.dist-info/RECORD,,
+ccburn-0.3.1.dist-info/licenses/LICENSE,sha256=Qf2mqNi2qJ35JytfoTdR1SgYhZ2Mt4Ohcf-tu_MuYC0,1068
+ccburn-0.3.1.dist-info/METADATA,sha256=UnlFr_QEFUjXnwh0ho0iw_1KHYesD7g_uzOL5DJSWjk,7343
+ccburn-0.3.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+ccburn-0.3.1.dist-info/entry_points.txt,sha256=GfFQ5VusMR8RJ9meygqWjaErdmYsf_arbILzf64WjLU,43
+ccburn-0.3.1.dist-info/top_level.txt,sha256=SM8TwGQZqQKKIQObVWQkfpA0OI4gRut7bPl-iM3g5RI,7
+ccburn-0.3.1.dist-info/RECORD,,