ripperdoc 0.2.9__py3-none-any.whl → 0.3.0__py3-none-any.whl

ripperdoc/utils/session_heatmap.py

@@ -0,0 +1,242 @@
+"""Activity heatmap visualization for session statistics."""
+
+from __future__ import annotations
+
+from datetime import datetime, timedelta
+from typing import Dict
+
+from rich.console import Console
+from rich.text import Text
+
+
+def _get_intensity_char(count: int, max_count: int) -> str:
+    """Get unicode block character based on activity intensity.
+
+    Returns character and color code for 8 intensity levels.
+    """
+    if count == 0:
+        return "·"
+    if max_count == 0:
+        return "█"
+
+    # Calculate intensity (0-1)
+    intensity = count / max_count
+
+    # Use unicode block characters for different intensities (8 levels)
+    if intensity <= 0.125:
+        return "░"
+    elif intensity <= 0.25:
+        return "░"
+    elif intensity <= 0.375:
+        return "▒"
+    elif intensity <= 0.5:
+        return "▒"
+    elif intensity <= 0.625:
+        return "▓"
+    elif intensity <= 0.75:
+        return "▓"
+    elif intensity <= 0.875:
+        return "█"
+    else:
+        return "█"
+
+
+def _get_intensity_color(count: int, max_count: int) -> str:
+    """Get color style based on activity intensity (8 levels)."""
+    if count == 0:
+        return "dim white"
+    if max_count == 0:
+        return "bold color(46)"
+
+    # Calculate intensity (0-1)
+    intensity = count / max_count
+
+    # 8-level green gradient from very light to very dark
+    if intensity <= 0.125:
+        return "color(22)"  # Very light green
+    elif intensity <= 0.25:
+        return "color(28)"  # Light green
+    elif intensity <= 0.375:
+        return "color(34)"  # Light-medium green
+    elif intensity <= 0.5:
+        return "color(40)"  # Medium green
+    elif intensity <= 0.625:
+        return "color(46)"  # Medium-dark green
+    elif intensity <= 0.75:
+        return "color(82)"  # Dark green
+    elif intensity <= 0.875:
+        return "bold color(46)"  # Bright green with bold
+    else:
+        return "bold color(82)"  # Very dark green with bold
+
+
+def _get_week_grid(
+    daily_activity: Dict[str, int], weeks_count: int = 52
+) -> tuple[list[list[tuple[str, int]]], int]:
+    """Build a grid of weeks for heatmap display.
+
+    Args:
+        daily_activity: Dictionary mapping date strings to activity counts
+        weeks_count: Number of weeks to display (default 52 for full year)
+
+    Returns:
+        Tuple of (grid, max_count) where grid is a list of weeks,
+        each week is a list of (date_str, count) tuples.
+    """
+    # Calculate total days to display
+    total_days = weeks_count * 7
+
+    # Start from today and go back
+    end_date = datetime.now().date()
+    start_date = end_date - timedelta(days=total_days - 1)
+
+    # Find max count for intensity calculation
+    max_count = max(daily_activity.values()) if daily_activity else 1
+
+    # Build grid by weeks (Sunday to Saturday)
+    weeks: list[list[tuple[str, int]]] = []
+    current_week: list[tuple[str, int]] = []
+
+    current_date = start_date
+    # Pad the start to align with week start (Sunday = 6 in Python's weekday, we want 0)
+    weekday = (current_date.weekday() + 1) % 7  # Convert to Sunday=0
+    if weekday > 0:
+        # Add empty days at the start
+        for _ in range(weekday):
+            current_week.append(("", 0))
+
+    while current_date <= end_date:
+        date_str = current_date.isoformat()
+        count = daily_activity.get(date_str, 0)
+        current_week.append((date_str, count))
+
+        # If we've completed a week (7 days), start a new week
+        if len(current_week) == 7:
+            weeks.append(current_week)
+            current_week = []
+
+        current_date += timedelta(days=1)
+
+    # Add remaining days
+    if current_week:
+        # Pad to complete the week
+        while len(current_week) < 7:
+            current_week.append(("", 0))
+        weeks.append(current_week)
+
+    return weeks, max_count
+
+
+def render_heatmap(console: Console, daily_activity: Dict[str, int], weeks_count: int = 52) -> None:
+    """Render activity heatmap to console.
+
+    Args:
+        console: Rich console for output
+        daily_activity: Dictionary mapping date strings to activity counts
+        weeks_count: Number of weeks to display (default 52 for full year)
+    """
+    # Alignment constant: width of weekday labels column
+    WEEKDAY_LABEL_WIDTH = 8
+
+    weeks, max_count = _get_week_grid(daily_activity, weeks_count)
+    if not weeks:
+        console.print("[dim]No activity data[/dim]")
+        return
+
+    # Build month labels row
+    # Each week column is exactly 1 character wide in the heatmap
+    # Month labels are 3 characters wide (e.g., "Dec", "Jan", "Feb")
+    month_positions = []  # List of (week_idx, month_name) tuples
+    current_month = None
+
+    for week_idx, week in enumerate(weeks):
+        # Check first non-empty day in week for month
+        for date_str, _ in week:
+            if date_str:
+                date = datetime.fromisoformat(date_str).date()
+                month_str = date.strftime("%b")
+
+                # Record position when month changes
+                if month_str != current_month:
+                    month_positions.append((week_idx, month_str))
+                    current_month = month_str
+                break
+
+    # Build month label string with precise alignment
+    month_chars = [" "] * len(weeks)
+
+    for week_idx, month_name in month_positions:
+        # Check if we have space for the full month name (3 chars)
+        can_place = True
+        for i in range(3):
+            if week_idx + i < len(month_chars) and month_chars[week_idx + i] != " ":
+                can_place = False
+                break
+
+        if can_place and week_idx < len(month_chars):
+            # Place the month name starting at this week position
+            for i, char in enumerate(month_name):
+                if week_idx + i < len(month_chars):
+                    month_chars[week_idx + i] = char
+
+    # Print month labels with proper alignment
+    month_row = " " * WEEKDAY_LABEL_WIDTH + "".join(month_chars)
+    console.print(month_row)
+
+    # Weekday labels - show Mon, Wed, Fri
+    weekday_labels = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"]
+    show_weekdays = [1, 3, 5]  # Show Mon, Wed, Fri
+
+    # Render each row (weekday)
+    for weekday_idx in range(7):
+        row = Text()
+
+        # Add weekday label - exactly WEEKDAY_LABEL_WIDTH characters
+        if weekday_idx in show_weekdays:
+            label = weekday_labels[weekday_idx]
+            # Right-align the label within the width, then add a space
+            row.append(f"{label:>3} ", style="dim")  # "Mon " = 4 chars
+            row.append(" " * (WEEKDAY_LABEL_WIDTH - 4))  # Fill remaining space
+        else:
+            row.append(" " * WEEKDAY_LABEL_WIDTH)
+
+        # Add activity cells for this weekday across all weeks
+        # Each week column is exactly 1 character wide
+        for week in weeks:
+            if weekday_idx < len(week):
+                date_str, count = week[weekday_idx]
+                if date_str:
+                    char = _get_intensity_char(count, max_count)
+                    color = _get_intensity_color(count, max_count)
+                    row.append(char, style=color)
+                else:
+                    row.append("·", style="dim white")
+            else:
+                row.append(" ")
+
+        console.print(row)
+
+    # Legend with 8-level green gradient
+    console.print()
+    legend = Text(" " * WEEKDAY_LABEL_WIDTH + "Less ", style="dim")
+    # Show representative levels from the 8-level gradient
+    legend.append("░", style="color(22)")  # Level 1: Very light green
+    legend.append(" ", style="dim")
+    legend.append("░", style="color(28)")  # Level 2: Light green
+    legend.append(" ", style="dim")
+    legend.append("▒", style="color(34)")  # Level 3: Light-medium green
+    legend.append(" ", style="dim")
+    legend.append("▒", style="color(40)")  # Level 4: Medium green
+    legend.append(" ", style="dim")
+    legend.append("▓", style="color(46)")  # Level 5: Medium-dark green
+    legend.append(" ", style="dim")
+    legend.append("▓", style="color(82)")  # Level 6: Dark green
+    legend.append(" ", style="dim")
+    legend.append("█", style="bold color(46)")  # Level 7: Bright green
+    legend.append(" ", style="dim")
+    legend.append("█", style="bold color(82)")  # Level 8: Very dark green
+    legend.append(" More", style="dim")
+    console.print(legend)
+
+
+__all__ = ["render_heatmap"]

ripperdoc/utils/session_history.py

@@ -6,7 +6,7 @@ import json
 from dataclasses import dataclass
 from datetime import datetime
 from pathlib import Path
-from typing import List, Optional
+from typing import List, Optional, Union
 
 from ripperdoc.utils.log import get_logger
 from ripperdoc.utils.messages import (
@@ -19,7 +19,7 @@ from ripperdoc.utils.path_utils import project_storage_dir
 
 logger = get_logger()
 
-ConversationMessage = UserMessage | AssistantMessage | ProgressMessage
+ConversationMessage = Union[UserMessage, AssistantMessage, ProgressMessage]
 
 
 @dataclass

ripperdoc/utils/session_stats.py

@@ -0,0 +1,294 @@
+"""Session statistics collection and analysis."""
+
+from __future__ import annotations
+
+from collections import defaultdict
+from dataclasses import dataclass, field
+from datetime import datetime, timedelta
+from pathlib import Path
+from typing import Dict, List, Tuple
+
+from ripperdoc.utils.log import get_logger
+from ripperdoc.utils.session_history import list_session_summaries
+
+logger = get_logger()
+
+
+@dataclass
+class SessionStats:
+    """Aggregated statistics across all sessions."""
+
+    # Basic counts
+    total_sessions: int = 0
+    total_messages: int = 0
+    total_cost_usd: float = 0.0
+
+    # Token statistics
+    total_tokens: int = 0
+    total_input_tokens: int = 0
+    total_output_tokens: int = 0
+    total_cache_read_tokens: int = 0
+    total_cache_creation_tokens: int = 0
+
+    # Model statistics (model -> count)
+    model_usage: Dict[str, int] = field(default_factory=dict)
+    favorite_model: str = ""
+
+    # Time statistics
+    longest_session_duration: timedelta = field(default_factory=lambda: timedelta(0))
+    earliest_session: datetime | None = None
+    latest_session: datetime | None = None
+
+    # Streak statistics
+    current_streak: int = 0
+    longest_streak: int = 0
+    active_days: int = 0
+    total_days: int = 0
+
+    # Activity patterns (hour -> count)
+    hourly_activity: Dict[int, int] = field(default_factory=dict)
+
+    # Daily activity (date_str -> count)
+    daily_activity: Dict[str, int] = field(default_factory=dict)
+
+    # Weekday activity (0=Monday -> 6=Sunday, count)
+    weekday_activity: Dict[int, int] = field(default_factory=dict)
+
+    # Peak hour (hour with most activity)
+    peak_hour: int = 0
+
+
+def _calculate_streaks(active_dates: List[datetime]) -> Tuple[int, int]:
+    """Calculate current and longest streak from sorted active dates."""
+    if not active_dates:
+        return 0, 0
+
+    # Sort dates
+    sorted_dates = sorted(set(d.date() for d in active_dates))
+
+    # Calculate longest streak
+    longest = 1
+    current = 1
+    for i in range(1, len(sorted_dates)):
+        if (sorted_dates[i] - sorted_dates[i - 1]).days == 1:
+            current += 1
+            longest = max(longest, current)
+        else:
+            current = 1
+
+    # Calculate current streak (from today backwards)
+    today = datetime.now().date()
+    current_streak = 0
+
+    # Check if today or yesterday has activity
+    if sorted_dates[-1] == today:
+        current_streak = 1
+        check_date = today - timedelta(days=1)
+    elif sorted_dates[-1] == today - timedelta(days=1):
+        current_streak = 1
+        check_date = sorted_dates[-1] - timedelta(days=1)
+    else:
+        return 0, longest
+
+    # Count backwards
+    i = len(sorted_dates) - 2
+    while i >= 0:
+        if sorted_dates[i] == check_date:
+            current_streak += 1
+            check_date -= timedelta(days=1)
+            i -= 1
+        else:
+            break
+
+    return current_streak, longest
+
+
+def collect_session_stats(project_path: Path, days: int = 32) -> SessionStats:
+    """Collect statistics from session history.
+
+    Args:
+        project_path: Project root directory
+        days: Number of days to look back (default 32)
+    """
+    stats = SessionStats(
+        hourly_activity=defaultdict(int),
+        daily_activity=defaultdict(int),
+        weekday_activity=defaultdict(int),
+        model_usage=defaultdict(int),
+    )
+
+    summaries = list_session_summaries(project_path)
+    if not summaries:
+        return stats
+
+    # Filter by date range (use timezone-aware cutoff if needed)
+    from datetime import timezone
+
+    cutoff = datetime.now(timezone.utc) - timedelta(days=days)
+
+    # Ensure comparison works with both naive and aware datetimes
+    recent_summaries = []
+    for s in summaries:
+        # Make updated_at timezone-aware if it's naive
+        updated_at = s.updated_at
+        if updated_at.tzinfo is None:
+            updated_at = updated_at.replace(tzinfo=timezone.utc)
+        if updated_at >= cutoff:
+            recent_summaries.append(s)
+
+    if not recent_summaries:
+        return stats
+
+    # Basic counts
+    stats.total_sessions = len(recent_summaries)
+    stats.total_messages = sum(s.message_count for s in recent_summaries)
+
+    # Time statistics
+    stats.earliest_session = min(s.created_at for s in recent_summaries)
+    stats.latest_session = max(s.updated_at for s in recent_summaries)
+    stats.total_days = (stats.latest_session - stats.earliest_session).days + 1
+
+    # Calculate longest session and activity patterns in single pass
+    active_dates: List[datetime] = []
+    date_set: set[str] = set()
+
+    for summary in recent_summaries:
+        # Longest session
+        duration = summary.updated_at - summary.created_at
+        if duration > stats.longest_session_duration:
+            stats.longest_session_duration = duration
+
+        # Track dates
+        date_str = summary.updated_at.date().isoformat()
+        if date_str not in date_set:
+            date_set.add(date_str)
+            active_dates.append(summary.updated_at)
+
+        # Hourly activity
+        stats.hourly_activity[summary.updated_at.hour] += 1
+
+        # Daily activity (for heatmap)
+        stats.daily_activity[date_str] += 1
+
+        # Weekday activity
+        stats.weekday_activity[summary.updated_at.weekday()] += 1
+
+    # Active days
+    stats.active_days = len(date_set)
+
+    # Streaks
+    stats.current_streak, stats.longest_streak = _calculate_streaks(active_dates)
+
+    # Peak hour
+    if stats.hourly_activity:
+        stats.peak_hour = max(stats.hourly_activity.items(), key=lambda x: x[1])[0]
+
+    # Load detailed session data for token and model statistics
+    import json
+
+    for summary in recent_summaries:
+        session_file = summary.path
+        if not session_file.exists():
+            continue
+
+        try:
+            with session_file.open("r", encoding="utf-8") as fh:
+                for line in fh:
+                    if not line.strip():
+                        continue
+                    # Quick string check before full JSON parse
+                    if '"type":"assistant"' not in line and '"type": "assistant"' not in line:
+                        continue
+                    try:
+                        entry = json.loads(line)
+                        payload = entry.get("payload", {})
+
+                        # Only process assistant messages
+                        if payload.get("type") != "assistant":
+                            continue
+
+                        # Extract model and token information
+                        model = payload.get("model")
+                        if model:
+                            stats.model_usage[model] += 1
+
+                        # Extract token counts
+                        input_tokens = payload.get("input_tokens", 0)
+                        output_tokens = payload.get("output_tokens", 0)
+                        cache_read = payload.get("cache_read_tokens", 0)
+                        cache_creation = payload.get("cache_creation_tokens", 0)
+
+                        stats.total_input_tokens += input_tokens
+                        stats.total_output_tokens += output_tokens
+                        stats.total_cache_read_tokens += cache_read
+                        stats.total_cache_creation_tokens += cache_creation
+
+                        # Extract cost
+                        cost = payload.get("cost_usd", 0.0)
+                        stats.total_cost_usd += cost
+
+                    except (json.JSONDecodeError, KeyError, TypeError, ValueError):
+                        continue
+        except (OSError, IOError):
+            continue
+
+    # Calculate total tokens
+    stats.total_tokens = (
+        stats.total_input_tokens
+        + stats.total_output_tokens
+        + stats.total_cache_read_tokens
+        + stats.total_cache_creation_tokens
+    )
+
+    # Determine favorite model
+    if stats.model_usage:
+        stats.favorite_model = max(stats.model_usage.items(), key=lambda x: x[1])[0]
+
+    return stats
+
+
+def format_duration(td: timedelta) -> str:
+    """Format timedelta as human-readable string."""
+    total_seconds = int(td.total_seconds())
+    if total_seconds < 60:
+        return f"{total_seconds}s"
+
+    minutes = total_seconds // 60
+    if minutes < 60:
+        seconds = total_seconds % 60
+        return f"{minutes}m {seconds}s"
+
+    hours = minutes // 60
+    remaining_mins = minutes % 60
+    if hours < 24:
+        return f"{hours}h {remaining_mins}m"
+
+    days = hours // 24
+    remaining_hours = hours % 24
+    return f"{days}d {remaining_hours}h {remaining_mins}m"
+
+
+def format_large_number(num: int) -> str:
+    """Format large numbers with k/m/b suffix.
+
+    Examples:
+        1234 -> "1.2k"
+        1234567 -> "1.2m"
+        1234567890 -> "1.2b"
+    """
+    if num < 1000:
+        return str(num)
+    elif num < 1_000_000:
+        return f"{num / 1000:.1f}k"
+    elif num < 1_000_000_000:
+        return f"{num / 1_000_000:.1f}m"
+    else:
+        return f"{num / 1_000_000_000:.1f}b"
+
+
+__all__ = [
+    "SessionStats",
+    "collect_session_stats",
+    "format_duration",
+    "format_large_number",
+]

ripperdoc/utils/shell_utils.py

@@ -9,15 +9,16 @@ from __future__ import annotations
 
 import os
 import shutil
+from pathlib import PureWindowsPath
 from typing import Iterable, List
 
 from ripperdoc.utils.log import get_logger
+from ripperdoc.utils.platform import is_windows
 
 logger = get_logger()
 
 # Common locations to probe if shutil.which misses an otherwise standard path.
 _COMMON_BIN_DIRS: tuple[str, ...] = ("/bin", "/usr/bin", "/usr/local/bin", "/opt/homebrew/bin")
-_IS_WINDOWS = os.name == "nt"
 
 
 def _is_executable(path: str) -> bool:
@@ -93,7 +94,7 @@ def find_suitable_shell() -> str:
     current_is_bash = "bash" in current_shell
     current_is_zsh = "zsh" in current_shell
 
-    if not _IS_WINDOWS:
+    if not is_windows():
         if (current_is_bash or current_is_zsh) and _is_executable(current_shell):
             logger.debug("Using SHELL from environment: %s", current_shell)
             return current_shell
@@ -149,9 +150,11 @@ def build_shell_command(shell_path: str, command: str) -> List[str]:
     For bash/zsh (including Git Bash), use -lc to run as login shell.
     For cmd.exe fallback, use /d /s /c.
     """
-
-    lower = shell_path.lower()
-    if lower.endswith("cmd.exe") or lower.endswith("\\cmd"):
+    # Use PureWindowsPath to correctly extract the shell name from the path.
+    # This handles both Windows-style (C:\\Windows\\System32\\cmd.exe) and Unix-style
+    # (/usr/bin/bash) paths, as well as simple names (cmd, bash) on any platform.
+    shell_name = PureWindowsPath(shell_path).name.lower()
+    if shell_name in ("cmd", "cmd.exe"):
         return [shell_path, "/d", "/s", "/c", command]
     return [shell_path, "-lc", command]
 

ripperdoc/utils/todo.py

@@ -185,12 +185,6 @@ def format_todo_summary(todos: Sequence[TodoItem]) -> str:
         f"{stats['by_status']['completed']} completed)."
     )
 
-    next_item = get_next_actionable(todos)
-    if next_item:
-        summary += f" Next to tackle: {next_item.content} (id: {next_item.id}, status: {next_item.status})."
-    elif stats["total"] == 0:
-        summary += " No todos stored yet."
-
     return summary