ripperdoc 0.2.3__py3-none-any.whl → 0.2.5__py3-none-any.whl

ripperdoc/cli/commands/permissions_cmd.py

@@ -0,0 +1,302 @@
+"""Slash command to manage permission rules."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any, List, Literal
+
+from rich.markup import escape
+from rich.panel import Panel
+from rich.table import Table
+
+from ripperdoc.core.config import (
+    config_manager,
+    get_global_config,
+    get_project_config,
+    get_project_local_config,
+    save_global_config,
+    save_project_config,
+    save_project_local_config,
+)
+
+from .base import SlashCommand
+
+
+ScopeType = Literal["user", "project", "local"]
+
+
+def _shorten_path(path: Path, project_path: Path) -> str:
+    """Return a short, user-friendly path."""
+    try:
+        return str(path.resolve().relative_to(project_path.resolve()))
+    except (ValueError, OSError):
+        pass
+
+    home = Path.home()
+    try:
+        rel_home = path.resolve().relative_to(home)
+        return f"~/{rel_home}"
+    except (ValueError, OSError):
+        return str(path)
+
+
+def _get_scope_info(scope: ScopeType, project_path: Path) -> tuple[str, str]:
+    """Return (heading, config_path) for a given scope."""
+    if scope == "user":
+        return "User (global)", str(Path.home() / ".ripperdoc.json")
+    elif scope == "project":
+        return "Project (shared)", str(project_path / ".ripperdoc" / "config.json")
+    else:  # local
+        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."""
+    if scope == "user":
+        config = get_global_config()
+        return list(config.user_allow_rules), list(config.user_deny_rules)
+    elif scope == "project":
+        config = get_project_config(project_path)
+        return list(config.bash_allow_rules), list(config.bash_deny_rules)
+    else:  # local
+        config = get_project_local_config(project_path)
+        return list(config.local_allow_rules), list(config.local_deny_rules)
+
+
+def _add_rule(
+    scope: ScopeType,
+    rule_type: Literal["allow", "deny"],
+    rule: str,
+    project_path: Path,
+) -> 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
+        if rule in rules:
+            return False
+        rules.append(rule)
+        save_global_config(config)
+    elif scope == "project":
+        config = get_project_config(project_path)
+        rules = config.bash_allow_rules if rule_type == "allow" else config.bash_deny_rules
+        if rule in rules:
+            return False
+        rules.append(rule)
+        save_project_config(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
+        if rule in rules:
+            return False
+        rules.append(rule)
+        save_project_local_config(config, project_path)
+    return True
+
+
+def _remove_rule(
+    scope: ScopeType,
+    rule_type: Literal["allow", "deny"],
+    rule: str,
+    project_path: Path,
+) -> 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
+        if rule not in rules:
+            return False
+        rules.remove(rule)
+        save_global_config(config)
+    elif scope == "project":
+        config = get_project_config(project_path)
+        rules = config.bash_allow_rules if rule_type == "allow" else config.bash_deny_rules
+        if rule not in rules:
+            return False
+        rules.remove(rule)
+        save_project_config(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
+        if rule not in rules:
+            return False
+        rules.remove(rule)
+        save_project_local_config(config, project_path)
+    return True
+
+
+def _render_all_rules(console: Any, project_path: Path) -> None:
+    """Display all permission rules from all scopes."""
+    table = Table(title="Permission Rules", show_header=True, header_style="bold cyan")
+    table.add_column("Scope", style="bold")
+    table.add_column("Type", style="dim")
+    table.add_column("Rule")
+
+    has_rules = False
+
+    for scope in ("user", "project", "local"):
+        allow_rules, deny_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 deny_rules:
+            table.add_row(scope, "[red]deny[/red]", escape(rule))
+            has_rules = True
+
+    if has_rules:
+        console.print(table)
+    else:
+        console.print("[yellow]No permission rules configured yet.[/yellow]")
+
+    console.print()
+    console.print("[dim]Scopes (in priority order):[/dim]")
+    console.print("[dim]  - user: Global rules (~/.ripperdoc.json)[/dim]")
+    console.print("[dim]  - project: Shared project rules (.ripperdoc/config.json)[/dim]")
+    console.print("[dim]  - local: Private project rules (.ripperdoc/config.local.json)[/dim]")
+
+
+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)
+
+    table = Table(title=f"{heading} Permission Rules", show_header=True, header_style="bold cyan")
+    table.add_column("Type", style="dim")
+    table.add_column("Rule")
+
+    has_rules = False
+    for rule in allow_rules:
+        table.add_row("[green]allow[/green]", escape(rule))
+        has_rules = True
+
+    for rule in deny_rules:
+        table.add_row("[red]deny[/red]", escape(rule))
+        has_rules = True
+
+    if has_rules:
+        console.print(table)
+    else:
+        console.print(f"[yellow]No {scope} rules configured.[/yellow]")
+
+    console.print(f"[dim]Config file: {escape(config_path)}[/dim]")
+
+
+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
+
+    # Parse command
+    action = args[0].lower()
+    scope_aliases = {
+        "user": "user",
+        "global": "user",
+        "project": "project",
+        "workspace": "project",
+        "local": "local",
+        "private": "local",
+    }
+
+    # Single scope display
+    if action in scope_aliases:
+        scope = scope_aliases[action]
+        _render_scope_rules(ui.console, scope, project_path)  # type: ignore
+        return True
+
+    # Add rule
+    if action == "add":
+        if len(args) < 4:
+            ui.console.print("[red]Usage: /permissions add <scope> <type> <rule>[/red]")
+            ui.console.print("[dim]Example: /permissions add local allow npm test[/dim]")
+            return True
+
+        scope_arg = args[1].lower()
+        if scope_arg not in scope_aliases:
+            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
+
+        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 = " ".join(args[3:])
+        if _add_rule(scope, rule_type, rule, project_path):
+            ui.console.print(
+                Panel(
+                    f"Added [{'green' if rule_type == 'allow' else 'red'}]{rule_type}[/] rule to {scope}:\n{escape(rule)}",
+                    title="/permissions",
+                )
+            )
+        else:
+            ui.console.print(f"[yellow]Rule already exists in {scope}.[/yellow]")
+        return True
+
+    # Remove rule
+    if action in ("remove", "rm", "delete", "del"):
+        if len(args) < 4:
+            ui.console.print("[red]Usage: /permissions remove <scope> <type> <rule>[/red]")
+            ui.console.print("[dim]Example: /permissions remove local allow npm test[/dim]")
+            return True
+
+        scope_arg = args[1].lower()
+        if scope_arg not in scope_aliases:
+            ui.console.print(f"[red]Unknown scope: {escape(scope_arg)}[/red]")
+            ui.console.print("[dim]Available scopes: user, project, local[/dim]")
+            return True
+        scope = scope_aliases[scope_arg]  # type: ignore
+
+        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 = rule_type_arg  # type: ignore
+
+        rule = " ".join(args[3:])
+        if _remove_rule(scope, 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)}",
+                    title="/permissions",
+                )
+            )
+        else:
+            ui.console.print(f"[yellow]Rule not found in {scope}.[/yellow]")
+        return True
+
+    # Unknown command
+    ui.console.print(f"[red]Unknown action: {escape(action)}[/red]")
+    ui.console.print("[dim]Available actions: add, remove, or a scope name[/dim]")
+    return True
+
+
+command = SlashCommand(
+    name="permissions",
+    description="Manage permission rules for tools",
+    handler=_handle,
+    aliases=(),
+)
+
+
+__all__ = ["command"]

ripperdoc/cli/commands/resume_cmd.py

@@ -61,8 +61,7 @@ def _choose_session(ui: Any, arg: str) -> Optional[SessionSummary]:
     idx = int(choice_text)
     if idx < 0 or idx >= len(sessions):
         ui.console.print(
-            f"[red]Invalid session index {escape(str(idx))}. "
-            f"Choose 0-{len(sessions) - 1}.[/red]"
+            f"[red]Invalid session index {escape(str(idx))}. Choose 0-{len(sessions) - 1}.[/red]"
         )
         return None
     return sessions[idx]

ripperdoc/cli/commands/tasks_cmd.py

@@ -105,10 +105,11 @@ def _list_tasks(ui: Any) -> bool:
     for task_id in sorted(task_ids):
         try:
             status = get_background_status(task_id, consume=False)
-        except Exception as exc:
+        except (KeyError, ValueError, RuntimeError, OSError) as exc:
             table.add_row(escape(task_id), "[red]error[/]", escape(str(exc)), "-")
-            logger.exception(
-                "[tasks_cmd] Failed to read background task status",
+            logger.warning(
+                "[tasks_cmd] Failed to read background task status: %s: %s",
+                type(exc).__name__, exc,
                 extra={"task_id": task_id, "session_id": getattr(ui, "session_id", None)},
             )
             continue
@@ -143,10 +144,11 @@ def _kill_task(ui: Any, task_id: str) -> bool:
     except KeyError:
         console.print(f"[red]No task found with id '{escape(task_id)}'.[/red]")
         return True
-    except Exception as exc:
+    except (ValueError, RuntimeError, OSError) as exc:
         console.print(f"[red]Failed to read task '{escape(task_id)}': {escape(str(exc))}[/red]")
-        logger.exception(
-            "[tasks_cmd] Failed to read task before kill",
+        logger.warning(
+            "[tasks_cmd] Failed to read task before kill: %s: %s",
+            type(exc).__name__, exc,
             extra={"task_id": task_id, "session_id": getattr(ui, "session_id", None)},
         )
         return True
@@ -157,12 +159,20 @@ def _kill_task(ui: Any, task_id: str) -> bool:
         )
         return True
 
+    runner = getattr(ui, "run_async", None)
+
     try:
-        killed = asyncio.run(kill_background_task(task_id))
-    except Exception as exc:
+        if callable(runner):
+            killed = runner(kill_background_task(task_id))
+        else:
+            killed = asyncio.run(kill_background_task(task_id))
+    except (OSError, RuntimeError, asyncio.CancelledError) as exc:
+        if isinstance(exc, asyncio.CancelledError):
+            raise
         console.print(f"[red]Error stopping task {escape(task_id)}: {escape(str(exc))}[/red]")
-        logger.exception(
-            "[tasks_cmd] Error stopping background task",
+        logger.warning(
+            "[tasks_cmd] Error stopping background task: %s: %s",
+            type(exc).__name__, exc,
             extra={"task_id": task_id, "session_id": getattr(ui, "session_id", None)},
         )
         return True
@@ -183,10 +193,11 @@ def _show_task(ui: Any, task_id: str) -> bool:
     except KeyError:
         console.print(f"[red]No task found with id '{escape(task_id)}'.[/red]")
         return True
-    except Exception as exc:
+    except (ValueError, RuntimeError, OSError) as exc:
         console.print(f"[red]Failed to read task '{escape(task_id)}': {escape(str(exc))}[/red]")
-        logger.exception(
-            "[tasks_cmd] Failed to read task for detail view",
+        logger.warning(
+            "[tasks_cmd] Failed to read task for detail view: %s: %s",
+            type(exc).__name__, exc,
             extra={"task_id": task_id, "session_id": getattr(ui, "session_id", None)},
         )
         return True