ripperdoc 0.2.6__py3-none-any.whl → 0.2.7__py3-none-any.whl

ripperdoc/__init__.py

@@ -1,3 +1,3 @@
 """Ripperdoc - AI-powered coding agent."""
 
-__version__ = "0.2.6"
+__version__ = "0.2.7"

ripperdoc/cli/commands/clear_cmd.py

@@ -12,6 +12,7 @@ command = SlashCommand(
     name="clear",
     description="Clear conversation history",
     handler=_handle,
+    aliases=("new",)
 )
 
 

ripperdoc/cli/commands/exit_cmd.py

@@ -12,7 +12,7 @@ command = SlashCommand(
     name="exit",
     description="Exit Ripperdoc",
     handler=_handle,
-    aliases=(),
+    aliases=("quit",),
 )
 
 

ripperdoc/cli/commands/resume_cmd.py

@@ -12,6 +12,9 @@ from ripperdoc.utils.session_history import (
 
 from .base import SlashCommand
 
+# Number of sessions to display per page
+PAGE_SIZE = 20
+
 
 def _format_time(dt: datetime) -> str:
     return dt.strftime("%Y-%m-%d %H:%M")
@@ -23,48 +26,79 @@ def _choose_session(ui: Any, arg: str) -> Optional[SessionSummary]:
         ui.console.print("[yellow]No saved sessions found for this project.[/yellow]")
         return None
 
-    # If a numeric arg is provided, try to resolve immediately.
+    # If arg is provided, treat it as session id prefix match
     if arg.strip():
-        if arg.isdigit():
-            idx = int(arg)
-            if 0 <= idx < len(sessions):
-                return sessions[idx]
+        match = next((s for s in sessions if s.session_id.startswith(arg.strip())), None)
+        if match:
+            return match
+        ui.console.print(f"[red]No session found matching '{escape(arg)}'.[/red]")
+        return None
+
+    # Pagination settings
+    current_page = 0
+    total_pages = (len(sessions) + PAGE_SIZE - 1) // PAGE_SIZE
+
+    while True:
+        start_idx = current_page * PAGE_SIZE
+        end_idx = min(start_idx + PAGE_SIZE, len(sessions))
+        page_sessions = sessions[start_idx:end_idx]
+
+        ui.console.print(f"\n[bold]Saved sessions (Page {current_page + 1}/{total_pages}):[/bold]")
+        for idx, summary in enumerate(page_sessions, start=start_idx):
             ui.console.print(
-                f"[red]Invalid session index {escape(str(idx))}. "
-                f"Choose 0-{len(sessions) - 1}.[/red]"
+                f"  [{idx}] {summary.session_id} "
+                f"({summary.message_count} messages, "
+                f"{_format_time(summary.created_at)} → {_format_time(summary.updated_at)}) "
+                f"{escape(summary.last_prompt)}",
+                markup=False,
             )
-        else:
-            # Treat arg as session id if it matches.
-            match = next((s for s in sessions if s.session_id.startswith(arg.strip())), None)
-            if match:
-                return match
-            ui.console.print(f"[red]No session found matching '{escape(arg)}'.[/red]")
-            return None
 
-    ui.console.print("\n[bold]Saved sessions:[/bold]")
-    for idx, summary in enumerate(sessions):
-        ui.console.print(
-            f"  [{idx}] {summary.session_id} "
-            f"({summary.message_count} messages, "
-            f"{_format_time(summary.created_at)} → {_format_time(summary.updated_at)}) "
-            f"{escape(summary.first_prompt)}",
-            markup=False,
-        )
-
-    choice_text = ui.console.input("\nSelect a session index (Enter to cancel): ").strip()
-    if not choice_text:
-        return None
-    if not choice_text.isdigit():
-        ui.console.print("[red]Please enter a number.[/red]")
-        return None
+        # Show navigation hints
+        nav_hints = []
+        if current_page > 0:
+            nav_hints.append("'p' for previous page")
+        if current_page < total_pages - 1:
+            nav_hints.append("'n' for next page")
+        nav_hints.append("Enter to cancel")
 
-    idx = int(choice_text)
-    if idx < 0 or idx >= len(sessions):
-        ui.console.print(
-            f"[red]Invalid session index {escape(str(idx))}. Choose 0-{len(sessions) - 1}.[/red]"
-        )
-        return None
-    return sessions[idx]
+        prompt = f"\nSelect session index"
+        if nav_hints:
+            prompt += f" ({', '.join(nav_hints)})"
+        prompt += ": "
+
+        choice_text = ui.console.input(prompt).strip().lower()
+
+        if not choice_text:
+            return None
+
+        # Handle pagination commands
+        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':
+            if current_page > 0:
+                current_page -= 1
+                continue
+            else:
+                ui.console.print("[yellow]Already at the first page.[/yellow]")
+                continue
+
+        # 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]")
+            continue
+
+        idx = int(choice_text)
+        if idx < 0 or idx >= len(sessions):
+            ui.console.print(
+                f"[red]Invalid session index {escape(str(idx))}. Choose 0-{len(sessions) - 1}.[/red]"
+            )
+            continue
+        return sessions[idx]
 
 
 def _handle(ui: Any, arg: str) -> bool:

ripperdoc/cli/ui/file_mention_completer.py

@@ -0,0 +1,221 @@
+"""File mention completer for @ symbol completion.
+
+This module provides file path completion when users type @ followed by a filename.
+Supports recursive search across the entire project.
+"""
+
+from pathlib import Path
+from typing import Any, Iterable, List
+
+from prompt_toolkit.completion import Completer, Completion
+
+from ripperdoc.utils.path_ignore import should_skip_path, IgnoreFilter
+
+
+class FileMentionCompleter(Completer):
+    """Autocomplete for file paths when typing @.
+
+    Supports recursive search - typing 'cli' will match 'ripperdoc/cli/cli.py'
+    """
+
+    def __init__(self, project_path: Path, ignore_filter: IgnoreFilter):
+        """Initialize the file mention completer.
+
+        Args:
+            project_path: Root path of the project
+            ignore_filter: Pre-built ignore filter for filtering files
+        """
+        self.project_path = project_path
+        self.ignore_filter = ignore_filter
+
+    def _collect_files_recursive(self, root_dir: Path, max_depth: int = 5) -> List[Path]:
+        """Recursively collect all files from root_dir, respecting ignore rules.
+
+        Args:
+            root_dir: Directory to search from
+            max_depth: Maximum directory depth to search
+
+        Returns:
+            List of file paths relative to project root
+        """
+        files = []
+
+        def _walk(current_dir: Path, depth: int):
+            if depth > max_depth:
+                return
+
+            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,
+                    ):
+                        continue
+
+                    if item.is_file():
+                        files.append(item)
+                    elif item.is_dir():
+                        # Recurse into subdirectory
+                        _walk(item, depth + 1)
+            except (OSError, PermissionError):
+                # Skip directories we can't read
+                pass
+
+        _walk(root_dir, 0)
+        return files
+
+    def get_completions(self, document: Any, complete_event: Any) -> Iterable[Completion]:
+        """Get completion suggestions for the current input.
+
+        Args:
+            document: The current document/input
+            complete_event: Completion event
+
+        Yields:
+            Completion objects with file paths
+        """
+        text = document.text_before_cursor
+
+        # Find the last @ symbol in the text
+        at_pos = text.rfind("@")
+        if at_pos == -1:
+            return
+
+        # Extract the query after the @ symbol
+        query = text[at_pos + 1:].strip()
+
+        try:
+            matches = []
+
+            # If query contains path separator, do directory-based search
+            if "/" in query or "\\" in query:
+                # User is typing a specific path
+                query_path = Path(query.replace("\\", "/"))
+
+                if query.endswith(("/", "\\")):
+                    # Show contents of this directory
+                    search_dir = self.project_path / query_path
+                    if search_dir.exists() and search_dir.is_dir():
+                        for item in sorted(search_dir.iterdir()):
+                            if should_skip_path(
+                                item,
+                                self.project_path,
+                                ignore_filter=self.ignore_filter,
+                                skip_hidden=True,
+                            ):
+                                continue
+
+                            try:
+                                rel_path = item.relative_to(self.project_path)
+                                display_path = str(rel_path)
+                                if item.is_dir():
+                                    display_path += "/"
+
+                                # Right side: show type only
+                                meta = "📁 directory" if item.is_dir() else "📄 file"
+
+                                matches.append((display_path, item, meta, 0))
+                            except ValueError:
+                                continue
+                else:
+                    # Match files in the parent directory
+                    parent_dir = self.project_path / query_path.parent
+                    pattern = f"{query_path.name}*"
+
+                    if parent_dir.exists() and parent_dir.is_dir():
+                        for item in sorted(parent_dir.iterdir()):
+                            if should_skip_path(
+                                item,
+                                self.project_path,
+                                ignore_filter=self.ignore_filter,
+                                skip_hidden=True,
+                            ):
+                                continue
+
+                            import fnmatch
+                            if fnmatch.fnmatch(item.name.lower(), pattern.lower()):
+                                try:
+                                    rel_path = item.relative_to(self.project_path)
+                                    display_path = str(rel_path)
+                                    if item.is_dir():
+                                        display_path += "/"
+
+                                    # Right side: show type only
+                                    meta = "📁 directory" if item.is_dir() else "📄 file"
+
+                                    matches.append((display_path, item, meta, 0))
+                                except ValueError:
+                                    continue
+            else:
+                # Recursive search: match query against filename anywhere in project
+                if not query:
+                    # No query: show top-level items only
+                    for item in sorted(self.project_path.iterdir()):
+                        if should_skip_path(
+                            item,
+                            self.project_path,
+                            ignore_filter=self.ignore_filter,
+                            skip_hidden=True,
+                        ):
+                            continue
+
+                        try:
+                            rel_path = item.relative_to(self.project_path)
+                            display_path = str(rel_path)
+                            if item.is_dir():
+                                display_path += "/"
+
+                            # Right side: show type only
+                            meta = "📁 directory" if item.is_dir() else "📄 file"
+                            matches.append((display_path, item, meta, 0))
+                        except ValueError:
+                            continue
+                else:
+                    # Recursively search for files matching the query
+                    all_files = self._collect_files_recursive(self.project_path)
+                    query_lower = query.lower()
+
+                    for file_path in all_files:
+                        try:
+                            rel_path = file_path.relative_to(self.project_path)
+                            file_name = file_path.name
+
+                            # Match against filename
+                            if query_lower in file_name.lower():
+                                # Calculate relevance score (prefer exact matches and shorter names)
+                                score = 0
+                                if file_name.lower().startswith(query_lower):
+                                    score += 100  # Prefix match is highly relevant
+                                if file_name.lower() == query_lower:
+                                    score += 200  # Exact match is most relevant
+                                score -= len(str(rel_path))  # Prefer shorter paths
+
+                                display_path = str(rel_path)
+
+                                # Right side: show type only
+                                meta = "📄 file"
+
+                                matches.append((display_path, file_path, meta, score))
+                        except ValueError:
+                            continue
+
+            # Sort matches by score (descending) and then by path
+            matches.sort(key=lambda x: (-x[3], x[0]))
+
+            # Limit results to prevent overwhelming the user
+            matches = matches[:50]
+
+            for display_path, item, meta, score in matches:
+                yield Completion(
+                    display_path,
+                    start_position=-(len(query) + 1),  # +1 to include the @ symbol
+                    display=display_path,
+                    display_meta=meta,
+                )
+
+        except (OSError, ValueError, RuntimeError):
+            # Silently ignore errors during completion
+            pass

ripperdoc/cli/ui/helpers.py

@@ -1,10 +1,107 @@
-"""Shared helper functions for the Rich UI."""
+"""Shared helper functions and constants for the Rich UI."""
 
-from typing import Optional
+import random
+from typing import List, Optional
 
 from ripperdoc.core.config import get_current_model_profile, get_global_config, ModelProfile
 
 
+# Fun words to display while the AI is "thinking"
+THINKING_WORDS: List[str] = [
+    "Accomplishing",
+    "Actioning",
+    "Actualizing",
+    "Baking",
+    "Booping",
+    "Brewing",
+    "Calculating",
+    "Cerebrating",
+    "Channelling",
+    "Churning",
+    "Coalescing",
+    "Cogitating",
+    "Computing",
+    "Combobulating",
+    "Concocting",
+    "Conjuring",
+    "Considering",
+    "Contemplating",
+    "Cooking",
+    "Crafting",
+    "Creating",
+    "Crunching",
+    "Deciphering",
+    "Deliberating",
+    "Determining",
+    "Discombobulating",
+    "Divining",
+    "Doing",
+    "Effecting",
+    "Elucidating",
+    "Enchanting",
+    "Envisioning",
+    "Finagling",
+    "Flibbertigibbeting",
+    "Forging",
+    "Forming",
+    "Frolicking",
+    "Generating",
+    "Germinating",
+    "Hatching",
+    "Herding",
+    "Honking",
+    "Ideating",
+    "Imagining",
+    "Incubating",
+    "Inferring",
+    "Manifesting",
+    "Marinating",
+    "Meandering",
+    "Moseying",
+    "Mulling",
+    "Mustering",
+    "Musing",
+    "Noodling",
+    "Percolating",
+    "Perusing",
+    "Philosophising",
+    "Pontificating",
+    "Pondering",
+    "Processing",
+    "Puttering",
+    "Puzzling",
+    "Reticulating",
+    "Ruminating",
+    "Scheming",
+    "Schlepping",
+    "Shimmying",
+    "Simmering",
+    "Smooshing",
+    "Spelunking",
+    "Spinning",
+    "Stewing",
+    "Sussing",
+    "Synthesizing",
+    "Thinking",
+    "Tinkering",
+    "Transmuting",
+    "Unfurling",
+    "Unravelling",
+    "Vibing",
+    "Wandering",
+    "Whirring",
+    "Wibbling",
+    "Wizarding",
+    "Working",
+    "Wrangling",
+]
+
+
+def get_random_thinking_word() -> str:
+    """Return a random thinking word for spinner display."""
+    return random.choice(THINKING_WORDS)
+
+
 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)
@@ -19,4 +116,4 @@ def get_profile_for_pointer(pointer: str = "main") -> Optional[ModelProfile]:
     return None
 
 
-__all__ = ["get_profile_for_pointer"]
+__all__ = ["get_profile_for_pointer", "THINKING_WORDS", "get_random_thinking_word"]

ripperdoc/cli/ui/interrupt_handler.py

@@ -0,0 +1,175 @@
+"""Interrupt handling for RichUI.
+
+This module handles ESC/Ctrl+C key detection during query execution,
+including terminal raw mode management.
+"""
+
+import asyncio
+import contextlib
+import sys
+from typing import Any, Optional, Set
+
+from ripperdoc.utils.log import get_logger
+
+logger = get_logger()
+
+# Keys that trigger interrupt
+INTERRUPT_KEYS: Set[str] = {'\x1b', '\x03'}  # ESC, Ctrl+C
+
+
+class InterruptHandler:
+    """Handles keyboard interrupt detection during async operations."""
+
+    def __init__(self):
+        """Initialize the interrupt handler."""
+        self._query_interrupted: bool = False
+        self._esc_listener_active: bool = False
+        self._esc_listener_paused: bool = False
+        self._stdin_fd: Optional[int] = None
+        self._stdin_old_settings: Optional[list] = None
+        self._stdin_in_raw_mode: bool = False
+        self._abort_callback: Optional[Any] = None
+
+    def set_abort_callback(self, callback: Any) -> None:
+        """Set the callback to trigger when interrupt is detected."""
+        self._abort_callback = callback
+
+    @property
+    def was_interrupted(self) -> bool:
+        """Check if the last query was interrupted."""
+        return self._query_interrupted
+
+    def pause_listener(self) -> bool:
+        """Pause ESC listener and restore cooked terminal mode if we own raw mode.
+
+        Returns:
+            Previous paused state for later restoration.
+        """
+        prev = self._esc_listener_paused
+        self._esc_listener_paused = True
+        try:
+            import termios
+        except ImportError:
+            return prev
+
+        if (
+            self._stdin_fd is not None
+            and self._stdin_old_settings is not None
+            and self._stdin_in_raw_mode
+        ):
+            with contextlib.suppress(OSError, termios.error, ValueError):
+                termios.tcsetattr(self._stdin_fd, termios.TCSADRAIN, self._stdin_old_settings)
+            self._stdin_in_raw_mode = False
+        return prev
+
+    def resume_listener(self, previous_state: bool) -> None:
+        """Restore paused state to what it was before a blocking prompt."""
+        self._esc_listener_paused = previous_state
+
+    async def _listen_for_interrupt_key(self) -> bool:
+        """Listen for interrupt keys (ESC/Ctrl+C) during query execution.
+
+        Uses raw terminal mode for immediate key detection without waiting
+        for escape sequences to complete.
+
+        Returns:
+            True if an interrupt key was pressed.
+        """
+        import select
+        import termios
+        import tty
+
+        try:
+            fd = sys.stdin.fileno()
+            old_settings = termios.tcgetattr(fd)
+        except (OSError, termios.error, ValueError):
+            return False
+
+        self._stdin_fd = fd
+        self._stdin_old_settings = old_settings
+        raw_enabled = False
+        try:
+            while self._esc_listener_active:
+                if self._esc_listener_paused:
+                    if raw_enabled:
+                        with contextlib.suppress(OSError, termios.error, ValueError):
+                            termios.tcsetattr(fd, termios.TCSADRAIN, old_settings)
+                        raw_enabled = False
+                        self._stdin_in_raw_mode = False
+                    await asyncio.sleep(0.05)
+                    continue
+
+                if not raw_enabled:
+                    tty.setraw(fd)
+                    raw_enabled = True
+                    self._stdin_in_raw_mode = True
+
+                await asyncio.sleep(0.02)
+                if select.select([sys.stdin], [], [], 0)[0]:
+                    if sys.stdin.read(1) in INTERRUPT_KEYS:
+                        return True
+        except (OSError, ValueError):
+            pass
+        finally:
+            self._stdin_in_raw_mode = False
+            with contextlib.suppress(OSError, termios.error, ValueError):
+                if raw_enabled:
+                    termios.tcsetattr(fd, termios.TCSADRAIN, old_settings)
+            self._stdin_fd = None
+            self._stdin_old_settings = None
+
+        return False
+
+    async def _cancel_task(self, task: asyncio.Task) -> None:
+        """Cancel a task and wait for it to finish."""
+        if not task.done():
+            task.cancel()
+            with contextlib.suppress(asyncio.CancelledError):
+                await task
+
+    def _trigger_abort(self) -> None:
+        """Signal the query to abort via callback."""
+        if self._abort_callback is not None:
+            self._abort_callback()
+
+    async def run_with_interrupt(self, query_coro: Any) -> bool:
+        """Run a coroutine with ESC key interrupt support.
+
+        Args:
+            query_coro: The coroutine to run with interrupt support.
+
+        Returns:
+            True if interrupted, False if completed normally.
+        """
+        self._query_interrupted = False
+        self._esc_listener_active = True
+
+        query_task = asyncio.create_task(query_coro)
+        interrupt_task = asyncio.create_task(self._listen_for_interrupt_key())
+
+        try:
+            done, _ = await asyncio.wait(
+                {query_task, interrupt_task},
+                return_when=asyncio.FIRST_COMPLETED
+            )
+
+            # Check if interrupted
+            if interrupt_task in done and interrupt_task.result():
+                self._query_interrupted = True
+                self._trigger_abort()
+                await self._cancel_task(query_task)
+                return True
+
+            # Query completed normally
+            if query_task in done:
+                await self._cancel_task(interrupt_task)
+                with contextlib.suppress(Exception):
+                    query_task.result()
+                return False
+
+            return False
+
+        finally:
+            self._esc_listener_active = False
+            await self._cancel_task(query_task)
+            await self._cancel_task(interrupt_task)