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

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

@@ -22,6 +22,12 @@ def _auth_token_display(profile: Optional[ModelProfile]) -> Tuple[str, Optional[
     if not profile:
         return ("Not configured", None)
 
+    # 首先检查全局 RIPPERDOC_AUTH_TOKEN
+    if os.getenv("RIPPERDOC_AUTH_TOKEN"):
+        return ("RIPPERDOC_AUTH_TOKEN (env)", "RIPPERDOC_AUTH_TOKEN")
+    if os.getenv("RIPPERDOC_API_KEY"):
+        return ("RIPPERDOC_API_KEY (env)", "RIPPERDOC_API_KEY")
+
     provider_value = (
         profile.provider.value if hasattr(profile.provider, "value") else str(profile.provider)
     )
@@ -44,6 +50,10 @@ def _api_base_display(profile: Optional[ModelProfile]) -> str:
     if not profile:
         return "API base URL: Not configured"
 
+    # 首先检查全局 RIPPERDOC_BASE_URL
+    if base_url := os.getenv("RIPPERDOC_BASE_URL"):
+        return f"API base URL: {base_url} (RIPPERDOC_BASE_URL env)"
+
     label_map = {
         ProviderType.ANTHROPIC: "Anthropic base URL",
         ProviderType.OPENAI_COMPATIBLE: "OpenAI-compatible base URL",

ripperdoc/cli/commands/tasks_cmd.py

@@ -100,13 +100,14 @@ def _list_tasks(ui: Any) -> bool:
     table.add_column("ID", style="cyan", no_wrap=True)
     table.add_column("Status", style="magenta", no_wrap=True)
     table.add_column("Command", style="white")
-    table.add_column("Duration", style="dim", no_wrap=True)
+    table.add_column("Runtime", style="dim", no_wrap=True)
+    table.add_column("Age", style="dim", no_wrap=True)
 
     for task_id in sorted(task_ids):
         try:
             status = get_background_status(task_id, consume=False)
         except (KeyError, ValueError, RuntimeError, OSError) as exc:
-            table.add_row(escape(task_id), "[red]error[/]", escape(str(exc)), "-")
+            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__,
@@ -122,6 +123,7 @@ def _list_tasks(ui: Any) -> bool:
             _format_status(status),
             escape(command_display),
             _format_duration(status.get("duration_ms")),
+            _format_duration(status.get("age_ms")),
         )
 
     console.print(
@@ -210,7 +212,8 @@ def _show_task(ui: Any, task_id: str) -> bool:
     details.add_row("ID", escape(task_id))
     details.add_row("Status", _format_status(status))
     details.add_row("Command", escape(status.get("command") or ""))
-    details.add_row("Duration", _format_duration(status.get("duration_ms")))
+    details.add_row("Runtime", _format_duration(status.get("duration_ms")))
+    details.add_row("Age", _format_duration(status.get("age_ms")))
     exit_code = status.get("exit_code")
     details.add_row("Exit code", str(exit_code) if exit_code is not None else "running")
 

ripperdoc/cli/commands/themes_cmd.py

@@ -0,0 +1,139 @@
+"""Theme management command for Ripperdoc.
+
+Allows users to list, preview, and switch UI themes.
+"""
+
+from typing import Any
+
+from rich.markup import escape
+from rich.table import Table
+
+from ripperdoc.core.config import get_global_config, save_global_config
+from ripperdoc.core.theme import (
+    BUILTIN_THEMES,
+    Theme,
+    get_theme_manager,
+)
+
+from .base import SlashCommand
+
+
+def _show_current_theme(ui: Any) -> None:
+    """Display current theme information."""
+    manager = get_theme_manager()
+    theme = manager.current
+    primary = manager.get_color("primary")
+    ui.console.print(f"\nCurrent theme: [bold {primary}]{theme.display_name}[/]")
+    ui.console.print(f"  {theme.description}")
+
+
+def _list_themes(ui: Any) -> None:
+    """List all available themes."""
+    manager = get_theme_manager()
+    current_name = manager.current.name
+
+    ui.console.print("\n[bold]Available Themes:[/bold]")
+
+    table = Table(show_header=False, box=None, padding=(0, 2))
+    table.add_column("Marker", width=2)
+    table.add_column("Name", width=16)
+    table.add_column("Description")
+
+    for name, theme in BUILTIN_THEMES.items():
+        is_current = name == current_name
+        marker = f"[{manager.get_color('primary')}]→[/]" if is_current else " "
+        display = (
+            f"[bold {manager.get_color('primary')}]{theme.display_name}[/]"
+            if is_current
+            else theme.display_name
+        )
+        table.add_row(marker, display, theme.description)
+
+    ui.console.print(table)
+    ui.console.print("\n[dim]Usage: /themes <name> to switch[/dim]")
+
+
+def _preview_theme(ui: Any, theme: Theme) -> None:
+    """Preview a theme's color palette."""
+    colors = theme.colors
+    ui.console.print(f"\n[bold]Theme Preview:[/bold] {theme.display_name}\n")
+
+    samples = [
+        ("Primary", colors.primary, "Brand color, borders"),
+        ("Secondary", colors.secondary, "Success, ready status"),
+        ("Error", colors.error, "Error messages"),
+        ("Warning", colors.warning, "Warning messages"),
+        ("Info", colors.info, "Info messages"),
+        ("Tool Call", colors.tool_call, "Tool invocations"),
+        ("Spinner", colors.spinner, "Loading indicator"),
+        ("Emphasis", colors.emphasis, "Highlighted text"),
+    ]
+
+    for label, color, desc in samples:
+        ui.console.print(f"  [{color}]■[/] {label}: {desc}")
+
+
+def _switch_theme(ui: Any, theme_name: str, preview_only: bool = False) -> None:
+    """Switch to a different theme."""
+    manager = get_theme_manager()
+
+    if theme_name not in BUILTIN_THEMES:
+        ui.console.print(f"[{manager.get_color('error')}]Unknown theme: {escape(theme_name)}[/]")
+        available = ", ".join(BUILTIN_THEMES.keys())
+        ui.console.print(f"[dim]Available themes: {available}[/dim]")
+        return
+
+    theme = BUILTIN_THEMES[theme_name]
+
+    if preview_only:
+        _preview_theme(ui, theme)
+        return
+
+    # Apply theme
+    manager.set_theme(theme_name)
+
+    # Persist to config
+    try:
+        config = get_global_config()
+        config.theme = theme_name
+        save_global_config(config)
+    except Exception as e:
+        ui.console.print(
+            f"[{manager.get_color('warning')}]Theme applied but failed to save: {e}[/]"
+        )
+        return
+
+    ui.console.print(f"[{manager.get_color('success')}]✓ Theme switched to {theme.display_name}[/]")
+
+
+def _handle(ui: Any, arg: str) -> bool:
+    """Handle the /themes command."""
+    arg = arg.strip().lower()
+
+    if not arg:
+        _show_current_theme(ui)
+        _list_themes(ui)
+        return True
+
+    parts = arg.split()
+
+    if parts[0] == "preview" and len(parts) > 1:
+        _switch_theme(ui, parts[1], preview_only=True)
+        return True
+
+    if parts[0] == "list":
+        _list_themes(ui)
+        return True
+
+    # Direct theme switch
+    _switch_theme(ui, parts[0])
+    return True
+
+
+command = SlashCommand(
+    name="themes",
+    description="List and switch UI themes",
+    handler=_handle,
+)
+
+__all__ = ["command"]

ripperdoc/cli/ui/file_mention_completer.py

@@ -10,6 +10,7 @@ from typing import Any, Iterable, List, Set
 from prompt_toolkit.completion import Completer, Completion
 
 from ripperdoc.utils.path_ignore import should_skip_path, IgnoreFilter
+from ripperdoc.utils.image_utils import is_image_file
 
 
 class FileMentionCompleter(Completer):
@@ -28,9 +29,33 @@ class FileMentionCompleter(Completer):
         self.project_path = project_path
         self.ignore_filter = ignore_filter
 
+    def _should_skip_for_completion(self, item: Path) -> bool:
+        """Check if an item should be skipped during completion.
+
+        Image files are never skipped since we support image input.
+
+        Args:
+            item: Path to check
+
+        Returns:
+            True if the item should be skipped
+        """
+        # Don't skip image files (we support them now)
+        if item.is_file() and is_image_file(item):
+            return False
+        # Use the project's ignore filter for other files
+        return should_skip_path(
+            item,
+            self.project_path,
+            ignore_filter=self.ignore_filter,
+            skip_hidden=True,
+        )
+
     def _collect_files_recursive(self, root_dir: Path, max_depth: int = 5) -> List[Path]:
         """Recursively collect all files from root_dir, respecting ignore rules.
 
+        Note: Image files are NOT filtered out since we support image input.
+
         Args:
             root_dir: Directory to search from
             max_depth: Maximum directory depth to search
@@ -46,13 +71,13 @@ class FileMentionCompleter(Completer):
 
             try:
                 for item in current_dir.iterdir():
-                    # Use the project's ignore filter to skip files
-                    if should_skip_path(
-                        item,
-                        self.project_path,
-                        ignore_filter=self.ignore_filter,
-                        skip_hidden=True,
-                    ):
+                    # Don't skip image files (we support them now)
+                    if item.is_file() and is_image_file(item):
+                        files.append(item)
+                        continue
+
+                    # Use the project's ignore filter to skip other files
+                    if self._should_skip_for_completion(item):
                         continue
 
                     if item.is_file():
@@ -122,7 +147,12 @@ class FileMentionCompleter(Completer):
                                     display_path += "/"
 
                                 # Right side: show type only
-                                meta = "📁 directory" if item.is_dir() else "📄 file"
+                                meta = "📁 directory"
+                                if item.is_file():
+                                    if is_image_file(item):
+                                        meta = "🖼️ image"
+                                    else:
+                                        meta = "📄 file"
 
                                 _add_match(display_path, item, meta, 0)
                             except ValueError:
@@ -152,7 +182,12 @@ class FileMentionCompleter(Completer):
                                         display_path += "/"
 
                                     # Right side: show type only
-                                    meta = "📁 directory" if item.is_dir() else "📄 file"
+                                    meta = "📁 directory"
+                                    if item.is_file():
+                                        if is_image_file(item):
+                                            meta = "🖼️ image"
+                                        else:
+                                            meta = "📄 file"
 
                                     _add_match(display_path, item, meta, 0)
                                 except ValueError:
@@ -177,7 +212,12 @@ class FileMentionCompleter(Completer):
                                 display_path += "/"
 
                             # Right side: show type only
-                            meta = "📁 directory" if item.is_dir() else "📄 file"
+                            meta = "📁 directory"
+                            if item.is_file():
+                                if is_image_file(item):
+                                    meta = "🖼️ image"
+                                else:
+                                    meta = "📄 file"
                             _add_match(display_path, item, meta, 0)
                         except ValueError:
                             continue
@@ -206,7 +246,12 @@ class FileMentionCompleter(Completer):
                             if item.is_dir():
                                 display_path += "/"
 
-                            meta = "📁 directory" if item.is_dir() else "📄 file"
+                            meta = "📁 directory"
+                            if item.is_file():
+                                if is_image_file(item):
+                                    meta = "🖼️ image"
+                                else:
+                                    meta = "📄 file"
                             _add_match(display_path, item, meta, score)
 
                     # If the query exactly matches a directory, also surface its children for quicker drilling
@@ -226,7 +271,12 @@ class FileMentionCompleter(Completer):
                                 display_path = str(rel_path)
                                 if item.is_dir():
                                     display_path += "/"
-                                meta = "📁 directory" if item.is_dir() else "📄 file"
+                                meta = "📁 directory"
+                                if item.is_file():
+                                    if is_image_file(item):
+                                        meta = "🖼️ image"
+                                    else:
+                                        meta = "📄 file"
                                 _add_match(display_path, item, meta, 400)
                             except ValueError:
                                 continue
@@ -267,7 +317,7 @@ class FileMentionCompleter(Completer):
             for display_path, item, meta, score in matches:
                 yield Completion(
                     display_path,
-                    start_position=-(len(query) + 1),  # +1 to include the @ symbol
+                    start_position=-len(query),
                     display=display_path,
                     display_meta=meta,
                 )

ripperdoc/cli/ui/helpers.py

@@ -3,7 +3,7 @@
 import random
 from typing import List, Optional
 
-from ripperdoc.core.config import get_current_model_profile, get_global_config, ModelProfile
+from ripperdoc.core.config import get_effective_model_profile, get_global_config, ModelProfile
 
 
 # Fun words to display while the AI is "thinking"
@@ -103,8 +103,11 @@ def get_random_thinking_word() -> str:
 
 
 def get_profile_for_pointer(pointer: str = "main") -> Optional[ModelProfile]:
-    """Return the configured ModelProfile for a logical pointer or default."""
-    profile = get_current_model_profile(pointer)
+    """Return the configured ModelProfile for a logical pointer or default.
+
+    此函数现在尊重 RIPPERDOC_* 环境变量的覆盖。
+    """
+    profile = get_effective_model_profile(pointer)
     if profile:
         return profile
     config = get_global_config()

ripperdoc/cli/ui/interrupt_handler.py

@@ -10,6 +10,7 @@ import sys
 from typing import Any, Optional, Set
 
 from ripperdoc.utils.log import get_logger
+from ripperdoc.utils.platform import is_windows
 
 logger = get_logger()
 
@@ -47,6 +48,11 @@ class InterruptHandler:
         """
         prev = self._esc_listener_paused
         self._esc_listener_paused = True
+
+        # Windows doesn't support termios
+        if is_windows():
+            return prev
+
         try:
             import termios
         except ImportError:
@@ -75,6 +81,34 @@ class InterruptHandler:
         Returns:
             True if an interrupt key was pressed.
         """
+        if is_windows():
+            # Windows: use msvcrt for non-blocking key detection
+            try:
+                import msvcrt
+            except ImportError:
+                # Fallback: just wait - Ctrl+C is handled by OS
+                while self._esc_listener_active:
+                    await asyncio.sleep(0.1)
+                return False
+
+            while self._esc_listener_active:
+                if self._esc_listener_paused:
+                    await asyncio.sleep(0.05)
+                    continue
+
+                # Check for key press in a thread to avoid blocking
+                def check_key() -> Optional[str]:
+                    if msvcrt.kbhit():  # type: ignore[attr-defined]
+                        return msvcrt.getch().decode("latin-1")  # type: ignore[attr-defined,no-any-return]
+                    return None
+
+                key = await asyncio.to_thread(check_key)
+                if key in INTERRUPT_KEYS:
+                    return True
+
+                await asyncio.sleep(0.02)
+            return False
+
         import select
         import termios
         import tty