ripperdoc 0.2.8__py3-none-any.whl → 0.2.10__py3-none-any.whl

ripperdoc/cli/commands/permissions_cmd.py

@@ -52,9 +52,7 @@ def _get_scope_info(scope: ScopeType, project_path: Path) -> tuple[str, str]:
         return "Local (private)", str(project_path / ".ripperdoc" / "config.local.json")
 
 
-def _get_rules_for_scope(
-    scope: ScopeType, project_path: Path
-) -> tuple[List[str], List[str]]:
+def _get_rules_for_scope(scope: ScopeType, project_path: Path) -> tuple[List[str], List[str]]:
     """Return (allow_rules, deny_rules) for a given scope."""
     if scope == "user":
         user_config: GlobalConfig = get_global_config()
@@ -76,21 +74,31 @@ def _add_rule(
     """Add a rule to the specified scope. Returns True if added, False if already exists."""
     if scope == "user":
         user_config: GlobalConfig = get_global_config()
-        rules = user_config.user_allow_rules if rule_type == "allow" else user_config.user_deny_rules
+        rules = (
+            user_config.user_allow_rules if rule_type == "allow" else user_config.user_deny_rules
+        )
         if rule in rules:
             return False
         rules.append(rule)
         save_global_config(user_config)
     elif scope == "project":
         project_config: ProjectConfig = get_project_config(project_path)
-        rules = project_config.bash_allow_rules if rule_type == "allow" else project_config.bash_deny_rules
+        rules = (
+            project_config.bash_allow_rules
+            if rule_type == "allow"
+            else project_config.bash_deny_rules
+        )
         if rule in rules:
             return False
         rules.append(rule)
         save_project_config(project_config, project_path)
     else:  # local
         local_config: ProjectLocalConfig = get_project_local_config(project_path)
-        rules = local_config.local_allow_rules if rule_type == "allow" else local_config.local_deny_rules
+        rules = (
+            local_config.local_allow_rules
+            if rule_type == "allow"
+            else local_config.local_deny_rules
+        )
         if rule in rules:
             return False
         rules.append(rule)
@@ -107,21 +115,31 @@ def _remove_rule(
     """Remove a rule from the specified scope. Returns True if removed, False if not found."""
     if scope == "user":
         user_config: GlobalConfig = get_global_config()
-        rules = user_config.user_allow_rules if rule_type == "allow" else user_config.user_deny_rules
+        rules = (
+            user_config.user_allow_rules if rule_type == "allow" else user_config.user_deny_rules
+        )
         if rule not in rules:
             return False
         rules.remove(rule)
         save_global_config(user_config)
     elif scope == "project":
         project_config: ProjectConfig = get_project_config(project_path)
-        rules = project_config.bash_allow_rules if rule_type == "allow" else project_config.bash_deny_rules
+        rules = (
+            project_config.bash_allow_rules
+            if rule_type == "allow"
+            else project_config.bash_deny_rules
+        )
         if rule not in rules:
             return False
         rules.remove(rule)
         save_project_config(project_config, project_path)
     else:  # local
         local_config: ProjectLocalConfig = get_project_local_config(project_path)
-        rules = local_config.local_allow_rules if rule_type == "allow" else local_config.local_deny_rules
+        rules = (
+            local_config.local_allow_rules
+            if rule_type == "allow"
+            else local_config.local_deny_rules
+        )
         if rule not in rules:
             return False
         rules.remove(rule)

ripperdoc/cli/commands/resume_cmd.py

@@ -72,14 +72,14 @@ def _choose_session(ui: Any, arg: str) -> Optional[SessionSummary]:
             return None
 
         # Handle pagination commands
-        if choice_text == 'n':
+        if choice_text == "n":
             if current_page < total_pages - 1:
                 current_page += 1
                 continue
             else:
                 ui.console.print("[yellow]Already at the last page.[/yellow]")
                 continue
-        elif choice_text == 'p':
+        elif choice_text == "p":
             if current_page > 0:
                 current_page -= 1
                 continue
@@ -89,7 +89,9 @@ def _choose_session(ui: Any, arg: str) -> Optional[SessionSummary]:
 
         # Handle session selection
         if not choice_text.isdigit():
-            ui.console.print("[red]Please enter a session index number, 'n' for next page, or 'p' for previous page.[/red]")
+            ui.console.print(
+                "[red]Please enter a session index number, 'n' for next page, or 'p' for previous page.[/red]"
+            )
             continue
 
         idx = int(choice_text)
@@ -114,6 +116,10 @@ def _handle(ui: Any, arg: str) -> bool:
     ui.conversation_messages = messages
     ui._saved_conversation = None
     ui._set_session(summary.session_id)
+    try:
+        ui._run_session_start("resume")
+    except (AttributeError, RuntimeError, ValueError):
+        pass
     ui.replay_conversation(messages)
     ui.console.print(
         f"[green]✓ Resumed session {escape(summary.session_id)} "

ripperdoc/cli/commands/stats_cmd.py

@@ -0,0 +1,244 @@
+"""Statistics command to show session usage patterns."""
+
+from typing import Any
+
+from rich.panel import Panel
+from rich.table import Table
+
+from ripperdoc.utils.session_heatmap import render_heatmap
+from ripperdoc.utils.session_stats import (
+    collect_session_stats,
+    format_duration,
+    format_large_number,
+)
+
+from .base import SlashCommand
+
+
+def _format_number(n: int) -> str:
+    """Format number with thousands separator."""
+    return f"{n:,}"
+
+
+def _truncate_model_name(model: str, max_len: int = 15) -> str:
+    """Truncate model name with ellipsis if too long."""
+    if len(model) <= max_len:
+        return model
+    return model[: max_len - 1] + "…"
+
+
+def _get_token_comparison(total_tokens: int) -> str:
+    """Get a fun comparison for total tokens based on famous books.
+
+    Reference data from famous books' approximate token counts.
+    """
+    books = [
+        ("The Old Man and the Sea", 35000),
+        ("Animal Farm", 39000),
+        ("The Great Gatsby", 62000),
+        ("Brave New World", 83000),
+        ("Harry Potter and the Philosopher's Stone", 103000),
+        ("The Hobbit", 123000),
+        ("1984", 123000),
+        ("To Kill a Mockingbird", 130000),
+        ("Pride and Prejudice", 156000),
+        ("Anna Karenina", 468000),
+        ("Don Quixote", 520000),
+        ("The Lord of the Rings", 576000),
+        ("War and Peace", 730000),
+    ]
+
+    if total_tokens == 0:
+        return "Start chatting to build your stats!"
+
+    # Find the best matching book
+    for i, (name, tokens) in enumerate(books):
+        if total_tokens < tokens:
+            if i == 0:
+                # Less than the smallest book
+                percentage = (total_tokens / tokens) * 100
+                return f"You've used {percentage:.0f}% of the tokens in {name}"
+            else:
+                # Between two books
+                prev_name, prev_tokens = books[i - 1]
+                if total_tokens >= prev_tokens * 1.5:
+                    # Closer to current book
+                    multiplier = total_tokens / tokens
+                    return f"You've used ~{multiplier:.1f}x the tokens in {name}"
+                else:
+                    # Closer to previous book
+                    multiplier = total_tokens / prev_tokens
+                    return f"You've used ~{multiplier:.1f}x the tokens in {prev_name}"
+
+    # More than the largest book
+    largest_name, largest_tokens = books[-1]
+    multiplier = total_tokens / largest_tokens
+    return f"You've used ~{multiplier:.1f}x the tokens in {largest_name}!"
+
+
+def _get_duration_comparison(duration_minutes: int) -> str:
+    """Get a fun comparison for session duration based on common activities.
+
+    Reference data for activity durations in minutes.
+    """
+    activities = [
+        ("a TED talk", 18),
+        ("an episode of The Office", 22),
+        ("a half marathon (average time)", 120),
+        ("the movie Inception", 148),
+        ("a transatlantic flight", 420),
+    ]
+
+    if duration_minutes == 0:
+        return ""
+
+    # Find the best matching activity
+    for i, (name, minutes) in enumerate(activities):
+        if duration_minutes < minutes:
+            if i == 0:
+                # Less than the shortest activity
+                percentage = (duration_minutes / minutes) * 100
+                return f"Longest session: {percentage:.0f}% of {name}"
+            else:
+                # Between two activities
+                prev_name, prev_minutes = activities[i - 1]
+                if duration_minutes >= prev_minutes * 1.5:
+                    # Closer to current activity
+                    multiplier = duration_minutes / minutes
+                    return f"Longest session: ~{multiplier:.1f}x {name}"
+                else:
+                    # Closer to previous activity
+                    multiplier = duration_minutes / prev_minutes
+                    return f"Longest session: ~{multiplier:.1f}x {prev_name}"
+
+    # More than the longest activity
+    longest_name, longest_minutes = activities[-1]
+    multiplier = duration_minutes / longest_minutes
+    return f"Longest session: ~{multiplier:.1f}x {longest_name}!"
+
+
+def _handle(ui: Any, _args: str) -> bool:
+    """Handle the stats command."""
+    # Get project path from UI
+    project_path = getattr(ui, "project_path", None)
+    if project_path is None:
+        ui.console.print("[yellow]No project context available[/yellow]")
+        return True
+
+    # Collect statistics
+    console = ui.console
+    days = 365  # Look back full year for complete heatmap
+    weeks_count = 52  # Display 52 weeks (1 year)
+    stats = collect_session_stats(project_path, days=days)
+
+    if stats.total_sessions == 0:
+        console.print("[yellow]No session data found[/yellow]")
+        return True
+
+    # Create overview panel
+    console.print()
+    console.print("[bold]Activity Heatmap[/bold]")
+    console.print()
+
+    # Render heatmap with full year (52 weeks)
+    render_heatmap(console, stats.daily_activity, weeks_count=weeks_count)
+    console.print()
+
+    # Create two-column layout for statistics
+    # Left column: Model and tokens
+    # Right column: Sessions and streaks
+    table = Table.grid(padding=(0, 4))
+    table.add_column(style="cyan", justify="left")
+    table.add_column(justify="left")
+    table.add_column(style="cyan", justify="left")
+    table.add_column(justify="left")
+
+    # Row 1: Favorite model | Sessions
+    favorite_model_display = ""
+    if stats.favorite_model:
+        favorite_model_display = _truncate_model_name(stats.favorite_model)
+    table.add_row(
+        "Favorite model:",
+        favorite_model_display or "N/A",
+        "Sessions:",
+        f"{_format_number(stats.total_sessions)}",
+    )
+
+    # Row 2: Total tokens | Longest session
+    total_tokens_display = format_large_number(stats.total_tokens) if stats.total_tokens > 0 else "0"
+    longest_session_display = ""
+    if stats.longest_session_duration.total_seconds() > 0:
+        longest_session_display = format_duration(stats.longest_session_duration)
+    table.add_row(
+        "Total tokens:",
+        total_tokens_display,
+        "Longest session:",
+        longest_session_display or "N/A",
+    )
+
+    # Row 3: empty | Current streak
+    table.add_row(
+        "",
+        "",
+        "Current streak:",
+        f"{stats.current_streak} days",
+    )
+
+    # Row 4: empty | Longest streak
+    table.add_row(
+        "",
+        "",
+        "Longest streak:",
+        f"{stats.longest_streak} days",
+    )
+
+    # Row 5: empty | Active days
+    table.add_row(
+        "",
+        "",
+        "Active days:",
+        f"{stats.active_days}/{stats.total_days}",
+    )
+
+    # Row 6: empty | Peak hour
+    peak_hour_str = f"{stats.peak_hour:02d}:00-{stats.peak_hour + 1:02d}:00"
+    table.add_row(
+        "",
+        "",
+        "Peak hour:",
+        peak_hour_str,
+    )
+
+    # Create the main panel with statistics
+    # Match heatmap width: WEEKDAY_LABEL_WIDTH (8) + weeks_count (52) = 60
+    heatmap_width = 8 + weeks_count + 16
+    console.print(
+        Panel(table, title="Statistics", border_style="blue", width=heatmap_width)
+    )
+    console.print()
+
+    # Fun comparisons
+    # Token comparison
+    token_comparison = _get_token_comparison(stats.total_tokens)
+    if token_comparison:
+        console.print(f"[dim]{token_comparison}[/dim]")
+
+    # Duration comparison
+    duration_minutes = int(stats.longest_session_duration.total_seconds() / 60)
+    duration_comparison = _get_duration_comparison(duration_minutes)
+    if duration_comparison:
+        console.print(f"[dim]{duration_comparison}[/dim]")
+
+    console.print(f"[dim]Stats from the last {days} days[/dim]")
+    console.print()
+
+    return True
+
+
+command = SlashCommand(
+    name="stats",
+    description="Show session statistics and activity patterns",
+    handler=_handle,
+)
+
+__all__ = ["command"]

ripperdoc/cli/commands/status_cmd.py

@@ -85,7 +85,7 @@ def _setting_sources_summary(
     profile: Optional[ModelProfile],
     memory_files: List[MemoryFile],
     auth_env_var: Optional[str],
-    safe_mode: bool,
+    yolo_mode: bool,
     verbose: bool,
     project_path: Path,
 ) -> str:
@@ -105,9 +105,9 @@ def _setting_sources_summary(
     if auth_env_var:
         sources.append("Environment variables")
 
-    config_safe_mode = getattr(config, "safe_mode", True)
+    config_yolo_mode = getattr(config, "yolo_mode", False)
     config_verbose = getattr(config, "verbose", False)
-    if safe_mode != config_safe_mode or verbose != config_verbose:
+    if yolo_mode != config_yolo_mode or verbose != config_verbose:
         sources.append("Command line arguments")
 
     if profile and profile.api_key and not auth_env_var:
@@ -133,7 +133,7 @@ def _handle(ui: Any, _: str) -> bool:
         profile,
         memory_files,
         auth_env_var,
-        ui.safe_mode,
+        ui.yolo_mode,
         ui.verbose,
         ui.project_path,
     )

ripperdoc/cli/commands/tasks_cmd.py

@@ -109,7 +109,8 @@ def _list_tasks(ui: Any) -> bool:
             table.add_row(escape(task_id), "[red]error[/]", escape(str(exc)), "-")
             logger.warning(
                 "[tasks_cmd] Failed to read background task status: %s: %s",
-                type(exc).__name__, exc,
+                type(exc).__name__,
+                exc,
                 extra={"task_id": task_id, "session_id": getattr(ui, "session_id", None)},
             )
             continue
@@ -148,7 +149,8 @@ def _kill_task(ui: Any, task_id: str) -> bool:
         console.print(f"[red]Failed to read task '{escape(task_id)}': {escape(str(exc))}[/red]")
         logger.warning(
             "[tasks_cmd] Failed to read task before kill: %s: %s",
-            type(exc).__name__, exc,
+            type(exc).__name__,
+            exc,
             extra={"task_id": task_id, "session_id": getattr(ui, "session_id", None)},
         )
         return True
@@ -172,7 +174,8 @@ def _kill_task(ui: Any, task_id: str) -> bool:
         console.print(f"[red]Error stopping task {escape(task_id)}: {escape(str(exc))}[/red]")
         logger.warning(
             "[tasks_cmd] Error stopping background task: %s: %s",
-            type(exc).__name__, exc,
+            type(exc).__name__,
+            exc,
             extra={"task_id": task_id, "session_id": getattr(ui, "session_id", None)},
         )
         return True
@@ -197,7 +200,8 @@ def _show_task(ui: Any, task_id: str) -> bool:
         console.print(f"[red]Failed to read task '{escape(task_id)}': {escape(str(exc))}[/red]")
         logger.warning(
             "[tasks_cmd] Failed to read task for detail view: %s: %s",
-            type(exc).__name__, exc,
+            type(exc).__name__,
+            exc,
             extra={"task_id": task_id, "session_id": getattr(ui, "session_id", None)},
         )
         return True

ripperdoc/cli/ui/file_mention_completer.py

@@ -85,7 +85,7 @@ class FileMentionCompleter(Completer):
             return
 
         # Extract the query after the @ symbol
-        query = text[at_pos + 1:].strip()
+        query = text[at_pos + 1 :].strip()
 
         try:
             matches = []
@@ -143,6 +143,7 @@ class FileMentionCompleter(Completer):
                                 continue
 
                             import fnmatch
+
                             if fnmatch.fnmatch(item.name.lower(), pattern.lower()):
                                 try:
                                     rel_path = item.relative_to(self.project_path)

ripperdoc/cli/ui/interrupt_handler.py

@@ -14,7 +14,7 @@ from ripperdoc.utils.log import get_logger
 logger = get_logger()
 
 # Keys that trigger interrupt
-INTERRUPT_KEYS: Set[str] = {'\x1b', '\x03'}  # ESC, Ctrl+C
+INTERRUPT_KEYS: Set[str] = {"\x1b", "\x03"}  # ESC, Ctrl+C
 
 
 class InterruptHandler:
@@ -149,8 +149,7 @@ class InterruptHandler:
 
         try:
             done, _ = await asyncio.wait(
-                {query_task, interrupt_task},
-                return_when=asyncio.FIRST_COMPLETED
+                {query_task, interrupt_task}, return_when=asyncio.FIRST_COMPLETED
             )
 
             # Check if interrupted

ripperdoc/cli/ui/message_display.py

@@ -22,15 +22,17 @@ ConversationMessage = Union[UserMessage, AssistantMessage, ProgressMessage]
 class MessageDisplay:
     """Handles message rendering and display operations."""
 
-    def __init__(self, console: Console, verbose: bool = False):
+    def __init__(self, console: Console, verbose: bool = False, show_full_thinking: bool = False):
         """Initialize the message display handler.
 
         Args:
             console: Rich console for output
             verbose: Whether to show verbose output
+            show_full_thinking: Whether to show full reasoning content instead of truncated preview
         """
         self.console = console
         self.verbose = verbose
+        self.show_full_thinking = show_full_thinking
 
     def format_tool_args(self, tool_name: str, tool_args: Optional[dict]) -> List[str]:
         """Render tool arguments into concise display-friendly parts."""
@@ -212,7 +214,7 @@ class MessageDisplay:
 
     def print_reasoning(self, reasoning: Any) -> None:
         """Display a collapsed preview of reasoning/thinking blocks."""
-        preview = format_reasoning_preview(reasoning)
+        preview = format_reasoning_preview(reasoning, self.show_full_thinking)
         if preview:
             self.console.print(f"[dim italic]Thinking: {escape(preview)}[/]")
 

ripperdoc/cli/ui/panels.py

@@ -55,6 +55,7 @@ def print_shortcuts(console: Console) -> None:
     pairs: List[Tuple[str, str]] = [
         ("? for shortcuts", "! for bash mode"),
         ("/ for commands", "@ for file mention"),
+        ("Alt+Enter for newline", "Enter to submit"),
     ]
     console.print("[dim]Shortcuts[/dim]")
     for left, right in pairs: