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

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_listener.py

@@ -0,0 +1,233 @@
+"""ESC key interrupt listener for the Rich UI."""
+
+from __future__ import annotations
+
+import os
+import sys
+import threading
+import time
+from typing import Any, Callable, Optional
+
+from ripperdoc.utils.log import get_logger
+
+if os.name != "nt":
+    import select
+    import termios
+    import tty
+
+
+class EscInterruptListener:
+    """Listen for ESC keypresses in a background thread and invoke a callback."""
+
+    def __init__(self, on_interrupt: Callable[[], None], *, logger: Optional[Any] = None) -> None:
+        self._on_interrupt = on_interrupt
+        self._logger = logger or get_logger()
+        self._thread: Optional[threading.Thread] = None
+        self._stop_event = threading.Event()
+        self._lock = threading.Lock()
+        self._pause_depth = 0
+        self._interrupt_sent = False
+        self._fd: Optional[int] = None
+        self._owns_fd = False
+        self._orig_termios = None
+        self._cbreak_active = False
+        self._availability_checked = False
+        self._available = True
+
+    @property
+    def is_running(self) -> bool:
+        return self._thread is not None and self._thread.is_alive()
+
+    def start(self) -> None:
+        if self.is_running or not self._available:
+            return
+        if os.name != "nt" and not self._setup_posix_input():
+            return
+        self._stop_event.clear()
+        with self._lock:
+            self._pause_depth = 0
+            self._interrupt_sent = False
+        self._thread = threading.Thread(
+            target=self._run,
+            name="ripperdoc-esc-listener",
+            daemon=True,
+        )
+        self._thread.start()
+
+    def stop(self) -> None:
+        self._stop_event.set()
+        if self._thread is not None:
+            self._thread.join(timeout=0.25)
+        self._thread = None
+        if os.name != "nt":
+            self._restore_posix_input()
+
+    def pause(self) -> None:
+        if os.name == "nt":
+            return
+        with self._lock:
+            self._pause_depth += 1
+            if self._pause_depth == 1:
+                self._restore_termios_locked()
+
+    def resume(self) -> None:
+        if os.name == "nt":
+            return
+        with self._lock:
+            if self._pause_depth == 0:
+                return
+            self._pause_depth -= 1
+            if self._pause_depth == 0:
+                self._apply_cbreak_locked()
+
+    def _run(self) -> None:
+        if os.name == "nt":
+            self._run_windows()
+        else:
+            self._run_posix()
+
+    def _run_windows(self) -> None:
+        import msvcrt
+
+        while not self._stop_event.is_set():
+            with self._lock:
+                paused = self._pause_depth > 0
+            if paused:
+                time.sleep(0.05)
+                continue
+            if msvcrt.kbhit():
+                ch = msvcrt.getwch()
+                if ch == "\x1b":
+                    self._signal_interrupt()
+            time.sleep(0.02)
+
+    def _run_posix(self) -> None:
+        while not self._stop_event.is_set():
+            with self._lock:
+                paused = self._pause_depth > 0
+                fd = self._fd
+            if paused or fd is None:
+                time.sleep(0.05)
+                continue
+            try:
+                readable, _, _ = select.select([fd], [], [], 0.1)
+            except (OSError, ValueError):
+                time.sleep(0.05)
+                continue
+            if not readable:
+                continue
+            try:
+                ch = os.read(fd, 1)
+            except OSError:
+                continue
+            if ch == b"\x1b":
+                if self._is_escape_sequence(fd):
+                    continue
+                self._signal_interrupt()
+
+    def _is_escape_sequence(self, fd: int) -> bool:
+        try:
+            readable, _, _ = select.select([fd], [], [], 0.02)
+        except (OSError, ValueError):
+            return False
+        if not readable:
+            return False
+        self._drain_pending_bytes(fd)
+        return True
+
+    def _drain_pending_bytes(self, fd: int) -> None:
+        while True:
+            try:
+                readable, _, _ = select.select([fd], [], [], 0)
+            except (OSError, ValueError):
+                return
+            if not readable:
+                return
+            try:
+                os.read(fd, 32)
+            except OSError:
+                return
+
+    def _signal_interrupt(self) -> None:
+        with self._lock:
+            if self._interrupt_sent:
+                return
+            self._interrupt_sent = True
+        try:
+            self._on_interrupt()
+        except (RuntimeError, ValueError, OSError) as exc:
+            self._logger.debug(
+                "[ui] ESC interrupt callback failed: %s: %s",
+                type(exc).__name__,
+                exc,
+            )
+
+    def _setup_posix_input(self) -> bool:
+        if self._fd is not None:
+            return True
+        fd: Optional[int] = None
+        owns = False
+        try:
+            if sys.stdin.isatty():
+                fd = sys.stdin.fileno()
+            elif os.path.exists("/dev/tty"):
+                fd = os.open("/dev/tty", os.O_RDONLY)
+                owns = True
+        except OSError as exc:
+            self._disable_listener(f"input error: {exc}")
+            return False
+        if fd is None:
+            self._disable_listener("no TTY available")
+            return False
+        try:
+            self._orig_termios = termios.tcgetattr(fd)
+        except (termios.error, OSError) as exc:
+            if owns:
+                try:
+                    os.close(fd)
+                except OSError:
+                    pass
+            self._disable_listener(f"termios unavailable: {exc}")
+            return False
+        self._fd = fd
+        self._owns_fd = owns
+        self._apply_cbreak_locked()
+        return True
+
+    def _restore_posix_input(self) -> None:
+        with self._lock:
+            self._restore_termios_locked()
+            if self._fd is not None and self._owns_fd:
+                try:
+                    os.close(self._fd)
+                except OSError:
+                    pass
+            self._fd = None
+            self._owns_fd = False
+            self._orig_termios = None
+            self._cbreak_active = False
+
+    def _apply_cbreak_locked(self) -> None:
+        if self._fd is None or self._orig_termios is None or self._cbreak_active:
+            return
+        try:
+            tty.setcbreak(self._fd)
+            self._cbreak_active = True
+        except (termios.error, OSError):
+            self._disable_listener("failed to enter cbreak mode")
+
+    def _restore_termios_locked(self) -> None:
+        if self._fd is None or self._orig_termios is None or not self._cbreak_active:
+            return
+        try:
+            termios.tcsetattr(self._fd, termios.TCSADRAIN, self._orig_termios)
+        except (termios.error, OSError):
+            pass
+        self._cbreak_active = False
+
+    def _disable_listener(self, reason: str) -> None:
+        if self._availability_checked:
+            return
+        self._availability_checked = True
+        self._available = False
+        self._logger.debug("[ui] ESC interrupt listener disabled: %s", reason)

ripperdoc/cli/ui/message_display.py

@@ -218,6 +218,13 @@ class MessageDisplay:
         if preview:
             self.console.print(f"[dim italic]Thinking: {escape(preview)}[/]")
 
+    def print_interrupt_notice(self) -> None:
+        """Display an interrupt notice when the user cancels with ESC."""
+        self.console.print(
+            "\n[red]■ Conversation interrupted[/red] · "
+            "[dim]Tell the model what to do differently.[/dim]"
+        )
+
 
 def parse_bash_output_sections(content: str) -> Tuple[List[str], List[str]]:
     """Parse stdout/stderr sections from a bash output text block."""

ripperdoc/cli/ui/panels.py

@@ -13,23 +13,27 @@ from rich import box
 
 from ripperdoc import __version__
 from ripperdoc.cli.ui.helpers import get_profile_for_pointer
+from ripperdoc.core.theme import theme_color
 
 
 def create_welcome_panel() -> Panel:
     """Create a welcome panel for the CLI startup."""
-    welcome_content = """
-[bold cyan]Welcome to Ripperdoc![/bold cyan]
+    primary = theme_color("primary")
+    muted = theme_color("text_secondary")
+
+    welcome_content = f"""
+[bold {primary}]Welcome to Ripperdoc![/bold {primary}]
 
 Ripperdoc is an AI-powered coding assistant that helps with software development tasks.
 You can read files, edit code, run commands, and help with various programming tasks.
 
-[dim]Type your questions below. Press Ctrl+C to exit.[/dim]
+[{muted}]Type your questions below. Press Ctrl+C twice to exit.[/{muted}]
 """
 
     return Panel(
         welcome_content,
         title=f"Ripperdoc v{__version__}",
-        border_style="cyan",
+        border_style=theme_color("border"),
         box=box.ROUNDED,
         padding=(1, 2),
     )
@@ -41,11 +45,11 @@ def create_status_bar() -> Text:
     model_name = profile.model if profile else "Not configured"
 
     status_text = Text()
-    status_text.append("Ripperdoc", style="bold cyan")
+    status_text.append("Ripperdoc", style=f"bold {theme_color('primary')}")
     status_text.append(" • ")
-    status_text.append(model_name, style="dim")
+    status_text.append(model_name, style=theme_color("text_secondary"))
     status_text.append(" • ")
-    status_text.append("Ready", style="green")
+    status_text.append("Ready", style=theme_color("secondary"))
 
     return status_text
 
@@ -57,7 +61,8 @@ def print_shortcuts(console: Console) -> None:
         ("/ for commands", "@ for file mention"),
         ("Alt+Enter for newline", "Enter to submit"),
     ]
-    console.print("[dim]Shortcuts[/dim]")
+    muted = theme_color("text_secondary")
+    console.print(f"[{muted}]Shortcuts[/{muted}]")
     for left, right in pairs:
         left_text = f"  {left}".ljust(32)
         right_text = f"{right}" if right else ""