ripperdoc 0.2.7__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

@@ -61,7 +61,7 @@ def _choose_session(ui: Any, arg: str) -> Optional[SessionSummary]:
             nav_hints.append("'n' for next page")
         nav_hints.append("Enter to cancel")
 
-        prompt = f"\nSelect session index"
+        prompt = "\nSelect session index"
         if nav_hints:
             prompt += f" ({', '.join(nav_hints)})"
         prompt += ": "

ripperdoc/cli/ui/file_mention_completer.py

@@ -5,7 +5,7 @@ Supports recursive search across the entire project.
 """
 
 from pathlib import Path
-from typing import Any, Iterable, List
+from typing import Any, Iterable, List, Set
 
 from prompt_toolkit.completion import Completer, Completion
 
@@ -40,7 +40,7 @@ class FileMentionCompleter(Completer):
         """
         files = []
 
-        def _walk(current_dir: Path, depth: int):
+        def _walk(current_dir: Path, depth: int) -> None:
             if depth > max_depth:
                 return
 
@@ -89,6 +89,13 @@ class FileMentionCompleter(Completer):
 
         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:
@@ -117,7 +124,7 @@ class FileMentionCompleter(Completer):
                                 # Right side: show type only
                                 meta = "📁 directory" if item.is_dir() else "📄 file"
 
-                                matches.append((display_path, item, meta, 0))
+                                _add_match(display_path, item, meta, 0)
                             except ValueError:
                                 continue
                 else:
@@ -146,7 +153,7 @@ class FileMentionCompleter(Completer):
                                     # Right side: show type only
                                     meta = "📁 directory" if item.is_dir() else "📄 file"
 
-                                    matches.append((display_path, item, meta, 0))
+                                    _add_match(display_path, item, meta, 0)
                                 except ValueError:
                                     continue
             else:
@@ -170,13 +177,61 @@ class FileMentionCompleter(Completer):
 
                             # Right side: show type only
                             meta = "📁 directory" if item.is_dir() else "📄 file"
-                            matches.append((display_path, item, meta, 0))
+                            _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)
-                    query_lower = query.lower()
 
                     for file_path in all_files:
                         try:
@@ -198,7 +253,7 @@ class FileMentionCompleter(Completer):
                                 # Right side: show type only
                                 meta = "📄 file"
 
-                                matches.append((display_path, file_path, meta, score))
+                                _add_match(display_path, file_path, meta, score)
                         except ValueError:
                             continue
 

ripperdoc/cli/ui/interrupt_handler.py

@@ -20,7 +20,7 @@ INTERRUPT_KEYS: Set[str] = {'\x1b', '\x03'}  # ESC, Ctrl+C
 class InterruptHandler:
     """Handles keyboard interrupt detection during async operations."""
 
-    def __init__(self):
+    def __init__(self) -> None:
         """Initialize the interrupt handler."""
         self._query_interrupted: bool = False
         self._esc_listener_active: bool = False

ripperdoc/cli/ui/message_display.py

@@ -6,7 +6,7 @@ This module handles rendering conversation messages to the terminal, including:
 - Reasoning block rendering
 """
 
-from typing import Any, Callable, Dict, List, Optional, Tuple, Union
+from typing import Any, Callable, List, Optional, Tuple, Union
 
 from rich.console import Console
 from rich.markdown import Markdown

ripperdoc/cli/ui/panels.py

@@ -12,6 +12,7 @@ from rich.text import Text
 from rich import box
 
 from ripperdoc import __version__
+from ripperdoc.cli.ui.helpers import get_profile_for_pointer
 
 
 def create_welcome_panel() -> Panel:
@@ -35,16 +36,18 @@ You can read files, edit code, run commands, and help with various programming t
 
 
 def create_status_bar() -> Text:
-    """Create a status bar text for display."""
-    text = Text()
-    text.append("Type ", style="dim")
-    text.append("/help", style="cyan")
-    text.append(" for commands | ", style="dim")
-    text.append("ESC", style="cyan")
-    text.append(" to interrupt | ", style="dim")
-    text.append("Ctrl+C", style="cyan")
-    text.append(" to exit", style="dim")
-    return text
+    """Create a status bar with current model information."""
+    profile = get_profile_for_pointer("main")
+    model_name = profile.model if profile else "Not configured"
+
+    status_text = Text()
+    status_text.append("Ripperdoc", style="bold cyan")
+    status_text.append(" • ")
+    status_text.append(model_name, style="dim")
+    status_text.append(" • ")
+    status_text.append("Ready", style="green")
+
+    return status_text
 
 
 def print_shortcuts(console: Console) -> None:

ripperdoc/cli/ui/rich_ui.py

@@ -4,37 +4,37 @@ This module provides a clean, minimal terminal UI using Rich for the Ripperdoc a
 """
 
 import asyncio
-import contextlib
 import json
-import os
 import sys
 import uuid
-import re
 from typing import List, Dict, Any, Optional, Union, Iterable
 from pathlib import Path
 
 from rich.console import Console
-from rich.markdown import Markdown
 from rich.markup import escape
 
 from prompt_toolkit import PromptSession
 from prompt_toolkit.completion import Completer, Completion, merge_completers
-from prompt_toolkit.shortcuts.prompt import CompleteStyle
 from prompt_toolkit.history import InMemoryHistory
 from prompt_toolkit.key_binding import KeyBindings
-from prompt_toolkit.document import Document
+from prompt_toolkit.shortcuts.prompt import CompleteStyle
 
 from ripperdoc.core.config import get_global_config, provider_protocol
 from ripperdoc.core.default_tools import get_default_tools
 from ripperdoc.core.query import query, QueryContext
 from ripperdoc.core.system_prompt import build_system_prompt
 from ripperdoc.core.skills import build_skill_summary, load_all_skills
+from ripperdoc.core.hooks.manager import hook_manager
 from ripperdoc.cli.commands import (
     get_slash_command,
+    get_custom_command,
     list_slash_commands,
+    list_custom_commands,
     slash_command_completions,
+    expand_command_content,
+    CustomCommandDefinition,
 )
-from ripperdoc.cli.ui.helpers import get_profile_for_pointer, THINKING_WORDS
+from ripperdoc.cli.ui.helpers import get_profile_for_pointer
 from ripperdoc.core.permissions import make_permission_checker
 from ripperdoc.cli.ui.spinner import Spinner
 from ripperdoc.cli.ui.thinking_spinner import ThinkingSpinner
@@ -72,7 +72,6 @@ from ripperdoc.utils.messages import (
     AssistantMessage,
     ProgressMessage,
     create_user_message,
-    create_assistant_message,
 )
 from ripperdoc.utils.log import enable_session_file_logging, get_logger
 from ripperdoc.utils.path_ignore import build_ignore_filter
@@ -113,7 +112,7 @@ class RichUI:
         self._current_tool: Optional[str] = None
         self._should_exit: bool = False
         self.command_list = list_slash_commands()
-        self._command_completions = slash_command_completions()
+        self._custom_command_list = list_custom_commands()
         self._prompt_session: Optional[PromptSession] = None
         self.project_path = Path.cwd()
         # Track a stable session identifier for the current UI run.
@@ -162,6 +161,17 @@ class RichUI:
                 extra={"session_id": self.session_id},
             )
 
+        # Initialize hook manager with project context
+        hook_manager.set_project_dir(self.project_path)
+        hook_manager.set_session_id(self.session_id)
+        logger.debug(
+            "[ui] Initialized hook manager",
+            extra={
+                "session_id": self.session_id,
+                "project_path": str(self.project_path),
+            },
+        )
+
     # ─────────────────────────────────────────────────────────────────────────────
     # Properties for backward compatibility with interrupt handler
     # ─────────────────────────────────────────────────────────────────────────────
@@ -452,7 +462,7 @@ class RichUI:
                         "tokens_saved": result.tokens_saved,
                     },
                 )
-                return result.messages  # type: ignore[return-value]
+                return result.messages
             elif isinstance(result, CompactionError):
                 logger.warning(
                     "[ui] Auto-compaction failed: %s",
@@ -789,8 +799,9 @@ class RichUI:
         """Public wrapper for running coroutines on the UI event loop."""
         return self._run_async(coro)
 
-    def handle_slash_command(self, user_input: str) -> bool:
-        """Handle slash commands. Returns True if the input was handled."""
+    def handle_slash_command(self, user_input: str) -> bool | str:
+        """Handle slash commands. Returns True if handled as built-in, False if not a command,
+        or a string if it's a custom command that should be sent to the AI."""
 
         if not user_input.startswith("/"):
             return False
@@ -802,12 +813,32 @@ class RichUI:
 
         command_name = parts[0].lower()
         trimmed_arg = " ".join(parts[1:]).strip()
+
+        # First, try built-in commands
         command = get_slash_command(command_name)
-        if command is None:
-            self.console.print(f"[red]Unknown command: {escape(command_name)}[/red]")
-            return True
+        if command is not None:
+            return command.handler(self, trimmed_arg)
+
+        # Then, try custom commands
+        custom_cmd = get_custom_command(command_name, self.project_path)
+        if custom_cmd is not None:
+            # Expand the custom command content
+            expanded_content = expand_command_content(
+                custom_cmd, trimmed_arg, self.project_path
+            )
 
-        return command.handler(self, trimmed_arg)
+            # Show a hint that this is from a custom command
+            self.console.print(
+                f"[dim]Running custom command: /{command_name}[/dim]"
+            )
+            if custom_cmd.argument_hint and trimmed_arg:
+                self.console.print(f"[dim]Arguments: {trimmed_arg}[/dim]")
+
+            # Return the expanded content to be processed as a query
+            return expanded_content
+
+        self.console.print(f"[red]Unknown command: {escape(command_name)}[/red]")
+        return True
 
     def get_prompt_session(self) -> PromptSession:
         """Create (or return) the prompt session with command completion."""
@@ -815,35 +846,68 @@ class RichUI:
             return self._prompt_session
 
         class SlashCommandCompleter(Completer):
-            """Autocomplete for slash commands."""
+            """Autocomplete for slash commands including custom commands."""
 
-            def __init__(self, completions: List):
-                self.completions = completions
+            def __init__(self, project_path: Path):
+                self.project_path = project_path
 
             def get_completions(self, document: Any, complete_event: Any) -> Iterable[Completion]:
                 text = document.text_before_cursor
                 if not text.startswith("/"):
                     return
                 query = text[1:]
-                for name, cmd in self.completions:
+                # Get completions including custom commands
+                completions = slash_command_completions(self.project_path)
+                for name, cmd in completions:
                     if name.startswith(query):
+                        # Handle both SlashCommand and CustomCommandDefinition
+                        description = cmd.description
+                        # Add hint for custom commands
+                        if isinstance(cmd, CustomCommandDefinition):
+                            hint = cmd.argument_hint or ""
+                            display = f"{name} {hint}".strip() if hint else name
+                            display_meta = f"[custom] {description}"
+                        else:
+                            display = name
+                            display_meta = description
                         yield Completion(
                             name,
                             start_position=-len(query),
-                            display=name,
-                            display_meta=cmd.description,
+                            display=display,
+                            display_meta=display_meta,
                         )
 
         # Merge both completers
-        slash_completer = SlashCommandCompleter(self._command_completions)
+        slash_completer = SlashCommandCompleter(self.project_path)
         file_completer = FileMentionCompleter(self.project_path, self._ignore_filter)
         combined_completer = merge_completers([slash_completer, file_completer])
 
+        key_bindings = KeyBindings()
+
+        @key_bindings.add("enter")
+        def _(event: Any) -> None:
+            """Accept completion if menu is open; otherwise submit line."""
+            buf = event.current_buffer
+            if buf.complete_state and buf.complete_state.current_completion:
+                buf.apply_completion(buf.complete_state.current_completion)
+                return
+            buf.validate_and_handle()
+
+        @key_bindings.add("tab")
+        def _(event: Any) -> None:
+            """Use Tab to accept the highlighted completion when visible."""
+            buf = event.current_buffer
+            if buf.complete_state and buf.complete_state.current_completion:
+                buf.apply_completion(buf.complete_state.current_completion)
+            else:
+                buf.start_completion(select_first=True)
+
         self._prompt_session = PromptSession(
             completer=combined_completer,
             complete_style=CompleteStyle.COLUMN,
             complete_while_typing=True,
             history=InMemoryHistory(),
+            key_bindings=key_bindings,
         )
         return self._prompt_session
 
@@ -888,7 +952,11 @@ class RichUI:
                         handled = self.handle_slash_command(user_input)
                         if self._should_exit:
                             break
-                        if handled:
+                        # If handled is a string, it's expanded custom command content
+                        if isinstance(handled, str):
+                            # Process the expanded custom command as a query
+                            user_input = handled
+                        elif handled:
                             console.print()  # spacing
                             continue