ccburn 0.1.0__py3-none-any.whl

ccburn/display/chart.py

@@ -0,0 +1,300 @@
+"""Plotext burnup chart with Rich integration."""
+
+from collections.abc import Generator
+from datetime import datetime, timedelta, timezone
+
+import plotext as plt
+from rich.ansi import AnsiDecoder
+from rich.console import Console, ConsoleOptions, Group, RenderableType
+from rich.jupyter import JupyterMixin
+
+try:
+    from ..data.models import LimitData, UsageSnapshot
+except ImportError:
+    from ccburn.data.models import LimitData, UsageSnapshot
+
+
+class BurnupChart(JupyterMixin):
+    """Rich-compatible burnup chart using plotext."""
+
+    def __init__(
+        self,
+        limit_data: LimitData | None,
+        snapshots: list[UsageSnapshot],
+        since: datetime | None = None,
+        explicit_height: int | 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)
+            explicit_height: Override chart height
+        """
+        self.limit_data = limit_data
+        self.snapshots = snapshots
+        self.since = since
+        self.explicit_height = explicit_height
+        self.decoder = AnsiDecoder()
+
+    def __rich_console__(
+        self, console: Console, options: ConsoleOptions
+    ) -> Generator[RenderableType, None, None]:
+        """Render the plotext chart for Rich console."""
+        width = options.max_width or console.width
+        height = self.explicit_height or options.height or 15
+
+        chart_str = self._create_chart(width, height)
+
+        # Decode ANSI and render using AnsiDecoder
+        rich_canvas = Group(*self.decoder.decode(chart_str))
+        yield rich_canvas
+
+    def _create_chart(self, width: int, height: int) -> str:
+        """Create the plotext chart.
+
+        Args:
+            width: Chart width in characters
+            height: Chart height in lines
+
+        Returns:
+            Rendered chart as string with ANSI codes
+        """
+        plt.clear_figure()
+        plt.clear_data()
+        plt.clear_color()
+
+        # Disable size limiter for larger charts
+        plt.limit_size(False, False)
+
+        # Configure plot size - use full available space
+        chart_width = max(width, 40)
+        chart_height = max(height, 8)
+        plt.plotsize(chart_width, chart_height)
+
+        if self.limit_data is None:
+            # No data - show empty chart
+            plt.title("No data available")
+            return plt.build()
+
+        # Determine time window - keep original window for pace calculation
+        original_window_start = self.limit_data.window_start
+        original_window_hours = self.limit_data.window_hours
+        window_end = self.limit_data.resets_at
+        now = datetime.now(timezone.utc)
+
+        # Display window (may be zoomed with --since)
+        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
+
+        # Filter snapshots to display window
+        relevant_snapshots = [
+            s for s in self.snapshots
+            if display_start <= s.timestamp <= now
+        ]
+
+        # Convert timestamps to relative hours from display start
+        def to_hours(dt: datetime) -> float:
+            return (dt - display_start).total_seconds() / 3600
+
+        display_hours = (display_end - display_start).total_seconds() / 3600
+
+        # Plot budget pace line - shows expected utilization at each point
+        # Based on ORIGINAL window, not zoomed view
+        num_points = 50
+        pace_x = []
+        pace_y = []
+        for i in range(num_points):
+            # X position in display coordinates
+            x_hours = i * display_hours / (num_points - 1)
+            pace_x.append(x_hours)
+            # Calculate actual time at this point
+            point_time = display_start + timedelta(hours=x_hours)
+            # Budget pace = how far through the ORIGINAL window we are
+            elapsed_in_original = (point_time - original_window_start).total_seconds() / 3600
+            pace_pct = (elapsed_in_original / original_window_hours) * 100
+            pace_y.append(min(pace_pct, 100.0))  # Cap at 100%
+        plt.plot(
+            pace_x,
+            pace_y,
+            color=(100, 100, 100),  # Dim gray RGB
+            marker="braille",
+            label="Budget Pace",
+        )
+
+        # Plot actual usage if we have data
+        values = []
+        if relevant_snapshots:
+            times = []
+
+            for s in relevant_snapshots:
+                limit = s.get_limit(self.limit_data.limit_type)
+                if limit:
+                    # Cap utilization to valid range (handles bad historical data)
+                    util_pct = min(limit.utilization * 100, 100.0)
+                    # Skip obviously bad data (utilization > 1.0 means unnormalized)
+                    if limit.utilization > 1.0:
+                        continue
+                    times.append(to_hours(s.timestamp))
+                    values.append(util_pct)
+
+            if times:
+                # Determine line color based on current utilization
+                color = self._get_plotext_color(self.limit_data.utilization)
+                # Use fillx=True for area chart effect (fills down to x-axis)
+                plt.plot(
+                    times,
+                    values,
+                    color=color,
+                    marker="braille",
+                    fillx=True,
+                    label="Usage",
+                )
+
+        # Configure axes
+        plt.xlim(0, display_hours)
+
+        # Y-axis: dynamic when zoomed (--since), fixed 0-100 otherwise
+        if self.since and values:
+            # Calculate dynamic range from data with padding
+            all_y_values = values + pace_y
+            data_min = min(all_y_values)
+            data_max = max(all_y_values)
+            # Add 10% padding for readability
+            padding = (data_max - data_min) * 0.1
+            y_min = max(0, data_min - padding)
+            y_max = min(100, data_max + padding)
+            # Ensure at least 10% range for visibility
+            if y_max - y_min < 10:
+                mid = (y_min + y_max) / 2
+                y_min = max(0, mid - 5)
+                y_max = min(100, mid + 5)
+        else:
+            y_min, y_max = 0, 100
+
+        plt.ylim(y_min, y_max)
+
+        # 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:
+            now_hours = to_hours(now)
+            if 0 < now_hours < display_hours:
+                # Create dotted vertical line with points using braille marker to match other lines
+                num_dots = 20
+                dot_y = [y_min + i * (y_max - y_min) / (num_dots - 1) for i in range(num_dots)]
+                dot_x = [now_hours] * num_dots
+                plt.plot(dot_x, dot_y, color=(0, 120, 255), marker="braille", label="Now")
+                now_hours_for_tick = now_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")
+
+        # Generate x-axis ticks with actual timestamps in local timezone
+        num_ticks = 5
+        tick_positions = []
+        tick_labels = []
+        # Use date format for windows > 24 hours
+        use_date_format = display_hours > 24
+        for i in range(num_ticks):
+            hours = i * display_hours / (num_ticks - 1)
+            tick_positions.append(hours)
+            # Convert to actual time in local timezone
+            tick_time = display_start + timedelta(hours=hours)
+            local_time = tick_time.astimezone()  # Convert to local timezone
+            # Round to nearest minute for stable display
+            if local_time.second >= 30:
+                local_time = local_time.replace(second=0, microsecond=0) + timedelta(minutes=1)
+            else:
+                local_time = local_time.replace(second=0, microsecond=0)
+            # Format based on window size
+            if use_date_format:
+                # Show day and time for multi-day windows (e.g., "Mon 15h")
+                tick_labels.append(local_time.strftime("%a %Hh"))
+            else:
+                # Show just time for short windows (e.g., "15:59")
+                tick_labels.append(local_time.strftime("%H:%M"))
+
+        # Add "Now" tick if showing the now line (show actual time)
+        # Remove any existing ticks that are too close to avoid overlap/flickering
+        if now_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 "Now"
+            filtered = [(pos, label) for pos, label in zip(tick_positions, tick_labels, strict=True)
+                        if abs(now_hours_for_tick - pos) >= min_distance]
+            tick_positions = [pos for pos, _ in filtered]
+            tick_labels = [label for _, label in filtered]
+            # Add the "Now" tick
+            tick_positions.append(now_hours_for_tick)
+            local_now = now.astimezone()
+            # Round to nearest minute
+            if local_now.second >= 30:
+                local_now = local_now.replace(second=0, microsecond=0) + timedelta(minutes=1)
+            else:
+                local_now = local_now.replace(second=0, microsecond=0)
+            if use_date_format:
+                tick_labels.append(local_now.strftime("%a %Hh"))
+            else:
+                tick_labels.append(local_now.strftime("%H:%M"))
+
+        plt.xticks(tick_positions, tick_labels)
+
+        # No labels on axes
+        plt.xlabel("")
+        plt.ylabel("")
+
+        # Theme and styling
+        plt.theme("dark")
+
+        # Use transparent/default background to match terminal
+        plt.canvas_color("default")
+        plt.axes_color("default")
+        plt.ticks_color((100, 100, 100))  # Dim gray for ticks/border
+
+        return plt.build()
+
+    def _get_plotext_color(self, utilization: float) -> tuple[int, int, int]:
+        """Get plotext RGB color based on utilization.
+
+        Args:
+            utilization: Current utilization (0-1)
+
+        Returns:
+            RGB tuple for plotext - bright vivid colors matching Rich progress bars
+        """
+        if utilization < 0.5:
+            return (0, 255, 0)  # Bright green
+        elif utilization < 0.75:
+            return (255, 255, 0)  # Bright yellow
+        elif utilization < 0.9:
+            return (255, 165, 0)  # Orange
+        else:
+            return (255, 0, 0)  # Bright red
+
+
+def create_simple_chart(
+    limit_data: LimitData | None,
+    snapshots: list[UsageSnapshot],
+    width: int = 80,
+    height: int = 15,
+    since: datetime | None = None,
+) -> str:
+    """Create a simple chart string without Rich integration.
+
+    Args:
+        limit_data: Current limit data
+        snapshots: Historical snapshots
+        width: Chart width
+        height: Chart height
+        since: Only show data since this time
+
+    Returns:
+        Rendered chart string
+    """
+    chart = BurnupChart(limit_data, snapshots, since=since, explicit_height=height)
+    return chart._create_chart(width, height)

ccburn/display/gauges.py

@@ -0,0 +1,275 @@
+"""Progress bar gauges for ccburn TUI."""
+
+from rich.progress import ProgressBar
+from rich.style import Style
+from rich.table import Table
+from rich.text import Text
+
+try:
+    from ..data.models import LimitData, LimitType
+    from ..utils.calculator import calculate_budget_pace
+    from ..utils.formatting import format_reset_time, get_utilization_color
+except ImportError:
+    from ccburn.data.models import LimitData, LimitType
+    from ccburn.utils.calculator import calculate_budget_pace
+    from ccburn.utils.formatting import format_reset_time, get_utilization_color
+
+
+def get_pace_emoji(utilization: float, budget_pace: float) -> str:
+    """Get emoji indicator based on utilization vs budget pace.
+
+    Args:
+        utilization: Current utilization (0-1)
+        budget_pace: Expected budget pace (0-1)
+
+    Returns:
+        Emoji: 🧊 (behind), 🔥 (on pace), 🚨 (ahead)
+    """
+    if budget_pace == 0:
+        return "🔥"
+
+    ratio = utilization / budget_pace
+    if ratio < 0.85:
+        return "🧊"  # Behind pace - ice cold, under budget
+    elif ratio > 1.15:
+        return "🚨"  # Ahead of pace - alarm!
+    else:
+        return "🔥"  # On pace - normal burn
+
+
+def create_header(limit_type: LimitType, limit_data: LimitData | None) -> Table:
+    """Create the header line with limit name and reset countdown.
+
+    Args:
+        limit_type: Which limit is being displayed
+        limit_data: Current limit data (for reset time)
+
+    Returns:
+        Rich Table formatted as a single header line
+    """
+    table = Table.grid(padding=0, expand=True)
+    table.add_column(justify="left", ratio=1)
+    table.add_column(justify="right", ratio=1)
+
+    # Dynamic pace emoji: 🧊 (behind), 🔥 (on pace), 🚨 (ahead)
+    if limit_data:
+        pace = calculate_budget_pace(limit_data.resets_at, limit_data.window_hours)
+        pace_emoji = get_pace_emoji(limit_data.utilization, pace)
+    else:
+        pace_emoji = "🔥"  # Default while loading
+
+    title = Text()
+    title.append(f"{pace_emoji} ", style="")
+    title.append("ccburn", style="bold magenta")
+    title.append(" - ", style="dim")
+    title.append(limit_type.display_name, style="bold cyan")
+
+    if limit_data:
+        reset_text = Text()
+        reset_text.append("⏰ ", style="")
+        reset_text.append(format_reset_time(limit_data.resets_at), style="yellow")
+    else:
+        reset_text = Text("⏳ Loading...", style="dim")
+
+    table.add_row(title, reset_text)
+    return table
+
+
+def create_gauge_section(
+    limit_data: LimitData | None,
+    budget_pace: float,
+) -> Table:
+    """Create the 2-bar gauge section for a limit.
+
+    Args:
+        limit_data: Current limit data
+        budget_pace: Percentage of window elapsed (0-1)
+
+    Returns:
+        Rich Table with Usage and Time Elapsed bars
+    """
+    table = Table.grid(padding=(0, 1), expand=True)
+    table.add_column(width=14)  # Label
+    table.add_column(ratio=1)  # Bar
+    table.add_column(width=8, justify="right")  # Value
+
+    if limit_data is None:
+        # Show empty/loading state
+        table.add_row(
+            Text("📊 Usage", style="dim"),
+            ProgressBar(total=100, completed=0, style=Style(color="dim")),
+            Text("--%", style="dim"),
+        )
+        table.add_row(
+            Text("⏳ Elapsed", style="dim"),
+            ProgressBar(total=100, completed=0, style=Style(color="dim")),
+            Text("--%", style="dim"),
+        )
+        return table
+
+    utilization_percent = limit_data.utilization * 100
+    pace_percent = budget_pace * 100
+
+    # Usage bar - color by threshold
+    # complete_style = filled portion (bright), style = unfilled portion (dim)
+    usage_color = get_utilization_color(limit_data.utilization)
+    usage_bar = ProgressBar(
+        total=100,
+        completed=utilization_percent,
+        style=Style(color="grey37"),  # Dim gray for unfilled
+        complete_style=Style(color=usage_color),  # Bright color for filled
+    )
+
+    # Usage label with emoji based on status
+    usage_emoji = "📊"
+    if limit_data.utilization >= 0.9:
+        usage_emoji = "🚨"
+    elif limit_data.utilization >= 0.75:
+        usage_emoji = "⚠️"
+
+    usage_label = Text()
+    usage_label.append(f"{usage_emoji} ", style="")
+    usage_label.append("Usage", style=f"bold {usage_color}")
+
+    table.add_row(
+        usage_label,
+        usage_bar,
+        Text(f"{utilization_percent:.0f}%", style=usage_color),
+    )
+
+    # Time Elapsed bar - always blue
+    # complete_style = filled portion (bright blue), style = unfilled portion (dim)
+    elapsed_bar = ProgressBar(
+        total=100,
+        completed=pace_percent,
+        style=Style(color="grey37"),  # Dim gray for unfilled
+        complete_style=Style(color="blue"),  # Bright blue for filled
+    )
+
+    time_label = Text()
+    time_label.append("⏳ ", style="")  # Use hourglass emoji (consistent width)
+    time_label.append("Elapsed", style="bold blue")
+
+    table.add_row(
+        time_label,
+        elapsed_bar,
+        Text(f"{pace_percent:.0f}%", style="blue"),
+    )
+
+    return table
+
+
+def create_compact_output(
+    session: LimitData | None,
+    weekly: LimitData | None,
+    weekly_sonnet: LimitData | None,
+    budget_pace_session: float,
+) -> str:
+    """Create compact single-line output for status bars.
+
+    Format: Session: 🧊 62% (2h14m) | Weekly: 🔥 29% | Sonnet: 🧊 1%
+    Emojis indicate pace: 🧊 (behind), 🔥 (on pace), 🚨 (ahead)
+
+    Args:
+        session: Session limit data
+        weekly: Weekly limit data
+        weekly_sonnet: Weekly sonnet limit data
+        budget_pace_session: Budget pace for session (for status indicator)
+
+    Returns:
+        Single-line string for status bar
+    """
+    from ..utils.formatting import format_duration
+
+    parts = []
+
+    # Session with time remaining
+    if session:
+        from datetime import datetime, timezone
+
+        now = datetime.now(timezone.utc)
+        minutes_left = int((session.resets_at - now).total_seconds() / 60)
+        time_str = f"({format_duration(minutes_left)})" if minutes_left > 0 else ""
+        pace = calculate_budget_pace(session.resets_at, session.window_hours)
+        emoji = get_pace_emoji(session.utilization, pace)
+        parts.append(f"Session: {emoji} {session.utilization*100:.0f}% {time_str}".strip())
+    else:
+        parts.append("Session: --")
+
+    # Weekly
+    if weekly:
+        pace = calculate_budget_pace(weekly.resets_at, weekly.window_hours)
+        emoji = get_pace_emoji(weekly.utilization, pace)
+        parts.append(f"Weekly: {emoji} {weekly.utilization*100:.0f}%")
+    else:
+        parts.append("Weekly: --")
+
+    # Sonnet
+    if weekly_sonnet:
+        pace = calculate_budget_pace(weekly_sonnet.resets_at, weekly_sonnet.window_hours)
+        emoji = get_pace_emoji(weekly_sonnet.utilization, pace)
+        parts.append(f"Sonnet: {emoji} {weekly_sonnet.utilization*100:.0f}%")
+    else:
+        parts.append("Sonnet: --")
+
+    return " | ".join(parts)
+
+
+def create_compact_output_with_indicator(
+    session: LimitData | None,
+    weekly: LimitData | None,
+    weekly_sonnet: LimitData | None,
+    budget_pace_session: float,
+) -> str:
+    """Create compact output with status indicator.
+
+    Format: [!] 62% (2h14m) | 29% | 1%
+
+    Args:
+        session: Session limit data
+        weekly: Weekly limit data
+        weekly_sonnet: Weekly sonnet limit data
+        budget_pace_session: Budget pace for session (for status indicator)
+
+    Returns:
+        Single-line string with status indicator
+    """
+    from ..utils.formatting import format_duration, get_status_indicator
+
+    # Determine which limit is most critical
+    max_util = 0.0
+    if session:
+        max_util = max(max_util, session.utilization)
+    if weekly:
+        max_util = max(max_util, weekly.utilization)
+    if weekly_sonnet:
+        max_util = max(max_util, weekly_sonnet.utilization)
+
+    indicator = get_status_indicator(max_util, budget_pace_session)
+
+    parts = [indicator]
+
+    # Session with time remaining
+    if session:
+        from datetime import datetime, timezone
+
+        now = datetime.now(timezone.utc)
+        minutes_left = int((session.resets_at - now).total_seconds() / 60)
+        time_str = f"({format_duration(minutes_left)})" if minutes_left > 0 else ""
+        parts.append(f"{session.utilization*100:.0f}% {time_str}".strip())
+    else:
+        parts.append("--")
+
+    # Weekly
+    if weekly:
+        parts.append(f"{weekly.utilization*100:.0f}%")
+    else:
+        parts.append("--")
+
+    # Sonnet
+    if weekly_sonnet:
+        parts.append(f"{weekly_sonnet.utilization*100:.0f}%")
+    else:
+        parts.append("--")
+
+    return " | ".join(parts)