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

ripperdoc/cli/commands/permissions_cmd.py

@@ -3,14 +3,16 @@
 from __future__ import annotations
 
 from pathlib import Path
-from typing import Any, List, Literal
+from typing import Any, Dict, List, Literal
 
 from rich.markup import escape
 from rich.panel import Panel
 from rich.table import Table
 
 from ripperdoc.core.config import (
-    config_manager,
+    GlobalConfig,
+    ProjectConfig,
+    ProjectLocalConfig,
     get_global_config,
     get_project_config,
     get_project_local_config,
@@ -55,14 +57,14 @@ def _get_rules_for_scope(
 ) -> tuple[List[str], List[str]]:
     """Return (allow_rules, deny_rules) for a given scope."""
     if scope == "user":
-        config = get_global_config()
-        return list(config.user_allow_rules), list(config.user_deny_rules)
+        user_config: GlobalConfig = get_global_config()
+        return list(user_config.user_allow_rules), list(user_config.user_deny_rules)
     elif scope == "project":
-        config = get_project_config(project_path)
-        return list(config.bash_allow_rules), list(config.bash_deny_rules)
+        project_config: ProjectConfig = get_project_config(project_path)
+        return list(project_config.bash_allow_rules), list(project_config.bash_deny_rules)
     else:  # local
-        config = get_project_local_config(project_path)
-        return list(config.local_allow_rules), list(config.local_deny_rules)
+        local_config: ProjectLocalConfig = get_project_local_config(project_path)
+        return list(local_config.local_allow_rules), list(local_config.local_deny_rules)
 
 
 def _add_rule(
@@ -73,26 +75,26 @@ def _add_rule(
 ) -> bool:
     """Add a rule to the specified scope. Returns True if added, False if already exists."""
     if scope == "user":
-        config = get_global_config()
-        rules = config.user_allow_rules if rule_type == "allow" else config.user_deny_rules
+        user_config: GlobalConfig = get_global_config()
+        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(config)
+        save_global_config(user_config)
     elif scope == "project":
-        config = get_project_config(project_path)
-        rules = config.bash_allow_rules if rule_type == "allow" else config.bash_deny_rules
+        project_config: ProjectConfig = get_project_config(project_path)
+        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(config, project_path)
+        save_project_config(project_config, project_path)
     else:  # local
-        config = get_project_local_config(project_path)
-        rules = config.local_allow_rules if rule_type == "allow" else config.local_deny_rules
+        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
         if rule in rules:
             return False
         rules.append(rule)
-        save_project_local_config(config, project_path)
+        save_project_local_config(local_config, project_path)
     return True
 
 
@@ -104,26 +106,26 @@ def _remove_rule(
 ) -> bool:
     """Remove a rule from the specified scope. Returns True if removed, False if not found."""
     if scope == "user":
-        config = get_global_config()
-        rules = config.user_allow_rules if rule_type == "allow" else config.user_deny_rules
+        user_config: GlobalConfig = get_global_config()
+        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(config)
+        save_global_config(user_config)
     elif scope == "project":
-        config = get_project_config(project_path)
-        rules = config.bash_allow_rules if rule_type == "allow" else config.bash_deny_rules
+        project_config: ProjectConfig = get_project_config(project_path)
+        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(config, project_path)
+        save_project_config(project_config, project_path)
     else:  # local
-        config = get_project_local_config(project_path)
-        rules = config.local_allow_rules if rule_type == "allow" else config.local_deny_rules
+        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
         if rule not in rules:
             return False
         rules.remove(rule)
-        save_project_local_config(config, project_path)
+        save_project_local_config(local_config, project_path)
     return True
 
 
@@ -204,7 +206,7 @@ def _handle(ui: Any, trimmed_arg: str) -> bool:
 
     # Parse command
     action = args[0].lower()
-    scope_aliases = {
+    scope_aliases: Dict[str, ScopeType] = {
         "user": "user",
         "global": "user",
         "project": "project",
@@ -215,8 +217,8 @@ def _handle(ui: Any, trimmed_arg: str) -> bool:
 
     # Single scope display
     if action in scope_aliases:
-        scope = scope_aliases[action]
-        _render_scope_rules(ui.console, scope, project_path)  # type: ignore
+        display_scope: ScopeType = scope_aliases[action]
+        _render_scope_rules(ui.console, display_scope, project_path)
         return True
 
     # Add rule
@@ -231,14 +233,14 @@ def _handle(ui: Any, trimmed_arg: str) -> bool:
             ui.console.print(f"[red]Unknown scope: {escape(scope_arg)}[/red]")
             ui.console.print("[dim]Available scopes: user, project, local[/dim]")
             return True
-        scope: ScopeType = scope_aliases[scope_arg]  # type: ignore
+        scope: ScopeType = scope_aliases[scope_arg]
 
         rule_type_arg = args[2].lower()
         if rule_type_arg not in ("allow", "deny"):
             ui.console.print(f"[red]Unknown rule type: {escape(rule_type_arg)}[/red]")
             ui.console.print("[dim]Available types: allow, deny[/dim]")
             return True
-        rule_type: Literal["allow", "deny"] = rule_type_arg  # type: ignore
+        rule_type: Literal["allow", "deny"] = rule_type_arg  # type: ignore[assignment]
 
         rule = " ".join(args[3:])
         if _add_rule(scope, rule_type, rule, project_path):
@@ -271,13 +273,13 @@ def _handle(ui: Any, trimmed_arg: str) -> bool:
             ui.console.print(f"[red]Unknown rule type: {escape(rule_type_arg)}[/red]")
             ui.console.print("[dim]Available types: allow, deny[/dim]")
             return True
-        rule_type = rule_type_arg  # type: ignore
+        remove_rule_type: Literal["allow", "deny"] = rule_type_arg  # type: ignore[assignment]
 
         rule = " ".join(args[3:])
-        if _remove_rule(scope, rule_type, rule, project_path):
+        if _remove_rule(scope, remove_rule_type, rule, project_path):
             ui.console.print(
                 Panel(
-                    f"Removed [{'green' if rule_type == 'allow' else 'red'}]{rule_type}[/] rule from {scope}:\n{escape(rule)}",
+                    f"Removed [{'green' if remove_rule_type == 'allow' else 'red'}]{remove_rule_type}[/] rule from {scope}:\n{escape(rule)}",
                     title="/permissions",
                 )
             )

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 = "\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,276 @@
+"""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, Set
+
+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) -> None:
+            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 = []
+            seen: Set[str] = set()
+
+            def _add_match(display_path: str, item: Path, meta: str, score: int) -> None:
+                if display_path in seen:
+                    return
+                seen.add(display_path)
+                matches.append((display_path, item, meta, score))
+
+            # 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"
+
+                                _add_match(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"
+
+                                    _add_match(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"
+                            _add_match(display_path, item, meta, 0)
+                        except ValueError:
+                            continue
+                else:
+                    # First, suggest top-level entries that match the prefix to support step-by-step navigation
+                    query_lower = query.lower()
+                    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
+
+                        name_lower = item.name.lower()
+                        if query_lower in name_lower:
+                            score = 500
+                            if name_lower.startswith(query_lower):
+                                score += 50
+                            if name_lower == query_lower:
+                                score += 100
+
+                            rel_path = item.relative_to(self.project_path)
+                            display_path = str(rel_path)
+                            if item.is_dir():
+                                display_path += "/"
+
+                            meta = "📁 directory" if item.is_dir() else "📄 file"
+                            _add_match(display_path, item, meta, score)
+
+                    # If the query exactly matches a directory, also surface its children for quicker drilling
+                    dir_candidate = self.project_path / query
+                    if dir_candidate.exists() and dir_candidate.is_dir():
+                        for item in sorted(dir_candidate.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 += "/"
+                                meta = "📁 directory" if item.is_dir() else "📄 file"
+                                _add_match(display_path, item, meta, 400)
+                            except ValueError:
+                                continue
+
+                    # Recursively search for files matching the query
+                    all_files = self._collect_files_recursive(self.project_path)
+
+                    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"
+
+                                _add_match(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"]