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

ripperdoc/cli/commands/permissions_cmd.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import sys
 from pathlib import Path
 from typing import Any, Dict, List, Literal
 
@@ -52,53 +53,72 @@ def _get_scope_info(scope: ScopeType, project_path: Path) -> tuple[str, str]:
         return "Local (private)", str(project_path / ".ripperdoc" / "config.local.json")
 
 
-def _get_rules_for_scope(scope: ScopeType, project_path: Path) -> tuple[List[str], List[str]]:
-    """Return (allow_rules, deny_rules) for a given scope."""
+def _get_rules_for_scope(
+    scope: ScopeType, project_path: Path
+) -> tuple[List[str], List[str], List[str]]:
+    """Return (allow_rules, deny_rules, ask_rules) for a given scope."""
     if scope == "user":
         user_config: GlobalConfig = get_global_config()
-        return list(user_config.user_allow_rules), list(user_config.user_deny_rules)
+        return (
+            list(user_config.user_allow_rules),
+            list(user_config.user_deny_rules),
+            list(user_config.user_ask_rules),
+        )
     elif scope == "project":
         project_config: ProjectConfig = get_project_config(project_path)
-        return list(project_config.bash_allow_rules), list(project_config.bash_deny_rules)
+        return (
+            list(project_config.bash_allow_rules),
+            list(project_config.bash_deny_rules),
+            list(project_config.bash_ask_rules),
+        )
     else:  # local
         local_config: ProjectLocalConfig = get_project_local_config(project_path)
-        return list(local_config.local_allow_rules), list(local_config.local_deny_rules)
+        return (
+            list(local_config.local_allow_rules),
+            list(local_config.local_deny_rules),
+            list(local_config.local_ask_rules),
+        )
 
 
 def _add_rule(
     scope: ScopeType,
-    rule_type: Literal["allow", "deny"],
+    rule_type: Literal["allow", "deny", "ask"],
     rule: str,
     project_path: Path,
 ) -> bool:
     """Add a rule to the specified scope. Returns True if added, False if already exists."""
     if scope == "user":
         user_config: GlobalConfig = get_global_config()
-        rules = (
-            user_config.user_allow_rules if rule_type == "allow" else user_config.user_deny_rules
-        )
+        if rule_type == "allow":
+            rules = user_config.user_allow_rules
+        elif rule_type == "deny":
+            rules = user_config.user_deny_rules
+        else:
+            rules = user_config.user_ask_rules
         if rule in rules:
             return False
         rules.append(rule)
         save_global_config(user_config)
     elif scope == "project":
         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_type == "allow":
+            rules = project_config.bash_allow_rules
+        elif rule_type == "deny":
+            rules = project_config.bash_deny_rules
+        else:
+            rules = project_config.bash_ask_rules
         if rule in rules:
             return False
         rules.append(rule)
         save_project_config(project_config, project_path)
     else:  # local
         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_type == "allow":
+            rules = local_config.local_allow_rules
+        elif rule_type == "deny":
+            rules = local_config.local_deny_rules
+        else:
+            rules = local_config.local_ask_rules
         if rule in rules:
             return False
         rules.append(rule)
@@ -108,38 +128,43 @@ def _add_rule(
 
 def _remove_rule(
     scope: ScopeType,
-    rule_type: Literal["allow", "deny"],
+    rule_type: Literal["allow", "deny", "ask"],
     rule: str,
     project_path: Path,
 ) -> bool:
     """Remove a rule from the specified scope. Returns True if removed, False if not found."""
     if scope == "user":
         user_config: GlobalConfig = get_global_config()
-        rules = (
-            user_config.user_allow_rules if rule_type == "allow" else user_config.user_deny_rules
-        )
+        if rule_type == "allow":
+            rules = user_config.user_allow_rules
+        elif rule_type == "deny":
+            rules = user_config.user_deny_rules
+        else:
+            rules = user_config.user_ask_rules
         if rule not in rules:
             return False
         rules.remove(rule)
         save_global_config(user_config)
     elif scope == "project":
         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_type == "allow":
+            rules = project_config.bash_allow_rules
+        elif rule_type == "deny":
+            rules = project_config.bash_deny_rules
+        else:
+            rules = project_config.bash_ask_rules
         if rule not in rules:
             return False
         rules.remove(rule)
         save_project_config(project_config, project_path)
     else:  # local
         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_type == "allow":
+            rules = local_config.local_allow_rules
+        elif rule_type == "deny":
+            rules = local_config.local_deny_rules
+        else:
+            rules = local_config.local_ask_rules
         if rule not in rules:
             return False
         rules.remove(rule)
@@ -157,12 +182,16 @@ def _render_all_rules(console: Any, project_path: Path) -> None:
     has_rules = False
 
     for scope in ("user", "project", "local"):
-        allow_rules, deny_rules = _get_rules_for_scope(scope, project_path)  # type: ignore
+        allow_rules, deny_rules, ask_rules = _get_rules_for_scope(scope, project_path)  # type: ignore
 
         for rule in allow_rules:
             table.add_row(scope, "[green]allow[/green]", escape(rule))
             has_rules = True
 
+        for rule in ask_rules:
+            table.add_row(scope, "[yellow]ask[/yellow]", escape(rule))
+            has_rules = True
+
         for rule in deny_rules:
             table.add_row(scope, "[red]deny[/red]", escape(rule))
             has_rules = True
@@ -182,7 +211,7 @@ def _render_all_rules(console: Any, project_path: Path) -> None:
 def _render_scope_rules(console: Any, scope: ScopeType, project_path: Path) -> None:
     """Display rules for a specific scope."""
     heading, config_path = _get_scope_info(scope, project_path)
-    allow_rules, deny_rules = _get_rules_for_scope(scope, project_path)
+    allow_rules, deny_rules, ask_rules = _get_rules_for_scope(scope, project_path)
 
     table = Table(title=f"{heading} Permission Rules", show_header=True, header_style="bold cyan")
     table.add_column("Type", style="dim")
@@ -193,6 +222,10 @@ def _render_scope_rules(console: Any, scope: ScopeType, project_path: Path) -> N
         table.add_row("[green]allow[/green]", escape(rule))
         has_rules = True
 
+    for rule in ask_rules:
+        table.add_row("[yellow]ask[/yellow]", escape(rule))
+        has_rules = True
+
     for rule in deny_rules:
         table.add_row("[red]deny[/red]", escape(rule))
         has_rules = True
@@ -205,22 +238,37 @@ def _render_scope_rules(console: Any, scope: ScopeType, project_path: Path) -> N
     console.print(f"[dim]Config file: {escape(config_path)}[/dim]")
 
 
+def _handle_permissions_tui(ui: Any) -> bool:
+    project_path = getattr(ui, "project_path", Path.cwd())
+    console = ui.console
+    if not sys.stdin.isatty():
+        console.print("[yellow]Interactive UI requires a TTY. Showing plain list instead.[/yellow]")
+        _render_all_rules(console, project_path)
+        return True
+
+    try:
+        from ripperdoc.cli.ui.permissions_tui import run_permissions_tui
+    except (ImportError, ModuleNotFoundError) as exc:
+        console.print(
+            f"[yellow]Textual UI not available ({escape(str(exc))}). Showing plain list.[/yellow]"
+        )
+        _render_all_rules(console, project_path)
+        return True
+
+    try:
+        return bool(run_permissions_tui(project_path))
+    except Exception as exc:  # noqa: BLE001 - fail safe in interactive UI
+        console.print(f"[red]Textual UI failed: {escape(str(exc))}[/red]")
+        _render_all_rules(console, project_path)
+        return True
+
+
 def _handle(ui: Any, trimmed_arg: str) -> bool:
     project_path = getattr(ui, "project_path", Path.cwd())
     args = trimmed_arg.strip().split()
 
-    # No args: show all rules
     if not args:
-        _render_all_rules(ui.console, project_path)
-        ui.console.print()
-        ui.console.print("[dim]Usage:[/dim]")
-        ui.console.print("[dim]  /permissions                     - Show all rules[/dim]")
-        ui.console.print("[dim]  /permissions <scope>             - Show rules for scope[/dim]")
-        ui.console.print("[dim]  /permissions add <scope> <type> <rule>   - Add a rule[/dim]")
-        ui.console.print("[dim]  /permissions remove <scope> <type> <rule> - Remove a rule[/dim]")
-        ui.console.print("[dim]Scopes: user, project, local[/dim]")
-        ui.console.print("[dim]Types: allow, deny[/dim]")
-        return True
+        return _handle_permissions_tui(ui)
 
     # Parse command
     action = args[0].lower()
@@ -233,6 +281,13 @@ def _handle(ui: Any, trimmed_arg: str) -> bool:
         "private": "local",
     }
 
+    if action in ("tui", "ui"):
+        return _handle_permissions_tui(ui)
+
+    if action in ("list", "ls"):
+        _render_all_rules(ui.console, project_path)
+        return True
+
     # Single scope display
     if action in scope_aliases:
         display_scope: ScopeType = scope_aliases[action]
@@ -254,11 +309,11 @@ def _handle(ui: Any, trimmed_arg: str) -> bool:
         scope: ScopeType = scope_aliases[scope_arg]
 
         rule_type_arg = args[2].lower()
-        if rule_type_arg not in ("allow", "deny"):
+        if rule_type_arg not in ("allow", "deny", "ask"):
             ui.console.print(f"[red]Unknown rule type: {escape(rule_type_arg)}[/red]")
-            ui.console.print("[dim]Available types: allow, deny[/dim]")
+            ui.console.print("[dim]Available types: allow, ask, deny[/dim]")
             return True
-        rule_type: Literal["allow", "deny"] = rule_type_arg  # type: ignore[assignment]
+        rule_type: Literal["allow", "deny", "ask"] = rule_type_arg  # type: ignore[assignment]
 
         rule = " ".join(args[3:])
         if _add_rule(scope, rule_type, rule, project_path):
@@ -287,11 +342,11 @@ def _handle(ui: Any, trimmed_arg: str) -> bool:
         scope = scope_aliases[scope_arg]  # type: ignore
 
         rule_type_arg = args[2].lower()
-        if rule_type_arg not in ("allow", "deny"):
+        if rule_type_arg not in ("allow", "deny", "ask"):
             ui.console.print(f"[red]Unknown rule type: {escape(rule_type_arg)}[/red]")
-            ui.console.print("[dim]Available types: allow, deny[/dim]")
+            ui.console.print("[dim]Available types: allow, ask, deny[/dim]")
             return True
-        remove_rule_type: Literal["allow", "deny"] = rule_type_arg  # type: ignore[assignment]
+        remove_rule_type: Literal["allow", "deny", "ask"] = rule_type_arg  # type: ignore[assignment]
 
         rule = " ".join(args[3:])
         if _remove_rule(scope, remove_rule_type, rule, project_path):

ripperdoc/cli/commands/resume_cmd.py

@@ -10,16 +10,26 @@ from ripperdoc.utils.session_history import (
     load_session_messages,
 )
 
+from ripperdoc.cli.ui.choice import ChoiceOption, prompt_choice, theme_style
+
 from .base import SlashCommand
 
 # Number of sessions to display per page
-PAGE_SIZE = 20
+PAGE_SIZE = 10
 
 
 def _format_time(dt: datetime) -> str:
     return dt.strftime("%Y-%m-%d %H:%M")
 
 
+def _truncate_prompt(prompt: str, max_length: int = 50) -> str:
+    """Truncate prompt text for display."""
+    prompt = prompt.strip()
+    if len(prompt) > max_length:
+        return prompt[:max_length - 3] + "..."
+    return prompt
+
+
 def _choose_session(ui: Any, arg: str) -> Optional[SessionSummary]:
     sessions = list_session_summaries(ui.project_path)
     if not sessions:
@@ -43,64 +53,64 @@ def _choose_session(ui: Any, arg: str) -> Optional[SessionSummary]:
         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"  [{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,
+        # Build choice options
+        options = []
+        for summary in page_sessions:
+            prompt_preview = _truncate_prompt(summary.last_prompt)
+            label = (
+                f"<info>{summary.session_id[:8]}...</info> "
+                f"({summary.message_count} msgs) "
+                f"<dim>{_format_time(summary.created_at)}</dim> "
+                f"<dim>{escape(prompt_preview)}</dim>"
             )
+            options.append(ChoiceOption(summary.session_id, label))
 
-        # Show navigation hints
-        nav_hints = []
+        # Add navigation options
+        nav_options = []
         if current_page > 0:
-            nav_hints.append("'p' for previous page")
+            nav_options.append(ChoiceOption(
+                "__prev__",
+                "<dim>←</dim> <dim>Previous page</dim>"
+            ))
         if current_page < total_pages - 1:
-            nav_hints.append("'n' for next page")
-        nav_hints.append("Enter to cancel")
-
-        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:
+            nav_options.append(ChoiceOption(
+                "__next__",
+                "<dim>→</dim> <dim>Next page</dim>"
+            ))
+
+        # Build the message
+        message = f"<question>Select a session to resume</question> <dim>(Page {current_page + 1}/{total_pages})</dim>"
+
+        # Combine options: sessions first, then navigation
+        all_options = options + nav_options
+
+        try:
+            result = prompt_choice(
+                message=message,
+                options=all_options,
+                title="Resume Session",
+                allow_esc=True,
+                esc_value="__cancel__",
+                style=theme_style(),
+            )
+        except (EOFError, KeyboardInterrupt):
             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]"
-            )
+        # Handle the result
+        if result == "__cancel__":
+            return None
+        elif result == "__next__":
+            current_page += 1
             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]"
-            )
+        elif result == "__prev__":
+            current_page -= 1
             continue
-        return sessions[idx]
+        else:
+            # Find and return the selected session
+            for s in sessions:
+                if s.session_id == result:
+                    return s
+            return None
 
 
 def _handle(ui: Any, arg: str) -> bool:

ripperdoc/cli/commands/themes_cmd.py

@@ -8,6 +8,7 @@ from typing import Any
 from rich.markup import escape
 from rich.table import Table
 
+from ripperdoc.cli.ui.choice import ChoiceOption, prompt_choice, theme_style
 from ripperdoc.core.config import get_global_config, save_global_config
 from ripperdoc.core.theme import (
     BUILTIN_THEMES,
@@ -111,8 +112,37 @@ def _handle(ui: Any, arg: str) -> bool:
     arg = arg.strip().lower()
 
     if not arg:
+        # Show current theme
         _show_current_theme(ui)
-        _list_themes(ui)
+
+        # Use choice component to select theme
+        manager = get_theme_manager()
+        current_name = manager.current.name
+
+        options = [
+            ChoiceOption(
+                name,
+                f"<info>{theme.display_name}</info>",
+                theme.description,
+                is_default=(name == current_name),
+            )
+            for name, theme in BUILTIN_THEMES.items()
+        ]
+
+        selected = prompt_choice(
+            message="<question>Choose a theme:</question>",
+            options=options,
+            title="Available Themes",
+            allow_esc=True,
+            esc_value=current_name,  # ESC keeps current theme
+            style=theme_style(),
+        )
+
+        if selected and selected != current_name:
+            _switch_theme(ui, selected)
+        elif selected == current_name:
+            ui.console.print(f"[dim]Theme remains {manager.current.display_name}[/dim]")
+
         return True
 
     parts = arg.split()

ripperdoc/cli/ui/agents_tui/__init__.py

@@ -0,0 +1,3 @@
+from .textual_app import run_agents_tui
+
+__all__ = ["run_agents_tui"]