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

@@ -0,0 +1,98 @@
+from typing import Any
+from datetime import datetime
+from typing import Optional
+
+from rich.markup import escape
+
+from ripperdoc.utils.session_history import (
+    SessionSummary,
+    list_session_summaries,
+    load_session_messages,
+)
+
+from .base import SlashCommand
+
+
+def _format_time(dt: datetime) -> str:
+    return dt.strftime("%Y-%m-%d %H:%M")
+
+
+def _choose_session(ui: Any, arg: str) -> Optional[SessionSummary]:
+    sessions = list_session_summaries(ui.project_path)
+    if not sessions:
+        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.strip():
+        if arg.isdigit():
+            idx = int(arg)
+            if 0 <= idx < len(sessions):
+                return sessions[idx]
+            ui.console.print(
+                f"[red]Invalid session index {escape(str(idx))}. "
+                f"Choose 0-{len(sessions) - 1}.[/red]"
+            )
+        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
+
+    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]
+
+
+def _handle(ui: Any, arg: str) -> bool:
+    summary = _choose_session(ui, arg)
+    if not summary:
+        return True
+
+    messages = load_session_messages(ui.project_path, summary.session_id)
+    if not messages:
+        ui.console.print("[red]Failed to load messages for the selected session.[/red]")
+        return True
+
+    ui.conversation_messages = messages
+    ui._saved_conversation = None
+    ui._set_session(summary.session_id)
+    ui.replay_conversation(messages)
+    ui.console.print(
+        f"[green]✓ Resumed session {escape(summary.session_id)} "
+        f"with {len(messages)} messages.[/green]"
+    )
+    return True
+
+
+command = SlashCommand(
+    name="resume",
+    description="Resume a previous session conversation",
+    handler=_handle,
+)
+
+
+__all__ = ["command"]

ripperdoc/cli/commands/status_cmd.py

@@ -0,0 +1,167 @@
+from typing import Any
+import os
+from pathlib import Path
+from typing import List, Optional, Tuple
+
+from ripperdoc import __version__
+from ripperdoc.cli.ui.helpers import get_profile_for_pointer
+from ripperdoc.core.config import (
+    ModelProfile,
+    ProviderType,
+    api_base_env_candidates,
+    api_key_env_candidates,
+    get_global_config,
+)
+from ripperdoc.utils.memory import MAX_CONTENT_LENGTH, MemoryFile, collect_all_memory_files
+
+from .base import SlashCommand
+
+
+def _auth_token_display(profile: Optional[ModelProfile]) -> Tuple[str, Optional[str]]:
+    """Return a safe auth token summary and the env var used, if any."""
+    if not profile:
+        return ("Not configured", None)
+
+    provider_value = (
+        profile.provider.value if hasattr(profile.provider, "value") else str(profile.provider)
+    )
+
+    env_candidates = api_key_env_candidates(profile.provider)
+    provider_env = f"{provider_value.upper()}_API_KEY" if provider_value else None
+    if provider_env and provider_env not in env_candidates:
+        env_candidates = [provider_env, *env_candidates]
+
+    env_var = next((name for name in env_candidates if os.environ.get(name)), None)
+    if env_var:
+        return (f"{env_var} (env)", env_var)
+    if profile.api_key or getattr(profile, "auth_token", None):
+        return ("Configured in profile", None)
+    return ("Missing", None)
+
+
+def _api_base_display(profile: Optional[ModelProfile]) -> str:
+    """Return a human-readable API base URL line."""
+    if not profile:
+        return "API base URL: Not configured"
+
+    label_map = {
+        ProviderType.ANTHROPIC: "Anthropic base URL",
+        ProviderType.OPENAI_COMPATIBLE: "OpenAI-compatible base URL",
+        ProviderType.GEMINI: "Gemini base URL",
+    }
+    label = label_map.get(profile.provider, "API base URL")
+    provider_value = (
+        profile.provider.value if hasattr(profile.provider, "value") else str(profile.provider)
+    )
+
+    env_candidates = api_base_env_candidates(profile.provider)
+    provider_env = f"{provider_value.upper()}_BASE_URL" if provider_value else None
+    if provider_env and provider_env not in env_candidates:
+        env_candidates = [provider_env, *env_candidates]
+
+    base_url = profile.api_base
+    if not base_url:
+        base_url = next(
+            (os.environ.get(name) for name in env_candidates if os.environ.get(name)), None
+        )
+
+    return f"{label}: {base_url or 'default'}"
+
+
+def _memory_status_lines(memory_files: List[MemoryFile]) -> List[str]:
+    """Summarize AGENTS memory files and any issues."""
+    if not memory_files:
+        return ["None detected"]
+
+    lines = [f"{len(memory_files)} file(s) loaded"]
+    oversized = [memory for memory in memory_files if len(memory.content) > MAX_CONTENT_LENGTH]
+    for memory in oversized:
+        lines.append(f"! {memory.path} ({len(memory.content)} chars > {MAX_CONTENT_LENGTH})")
+    return lines
+
+
+def _setting_sources_summary(
+    config: Any,
+    profile: Optional[ModelProfile],
+    memory_files: List[MemoryFile],
+    auth_env_var: Optional[str],
+    safe_mode: bool,
+    verbose: bool,
+    project_path: Path,
+) -> str:
+    """Describe where settings for this session were sourced from."""
+    sources: list[str] = []
+    if (Path.home() / ".ripperdoc.json").exists():
+        sources.append("User settings")
+
+    project_config_path = project_path / ".ripperdoc" / "config.json"
+    if project_config_path.exists():
+        sources.append("Project settings")
+
+    if any(memory.type == "Local" for memory in memory_files):
+        sources.append("Local memory")
+    if any(memory.type == "Project" for memory in memory_files):
+        sources.append("Project memory")
+    if auth_env_var:
+        sources.append("Environment variables")
+
+    config_safe_mode = getattr(config, "safe_mode", True)
+    config_verbose = getattr(config, "verbose", False)
+    if safe_mode != config_safe_mode or verbose != config_verbose:
+        sources.append("Command line arguments")
+
+    if profile and profile.api_key and not auth_env_var:
+        sources.append("Profile configuration")
+
+    if not sources:
+        sources.append("Defaults")
+
+    unique_sources = list(dict.fromkeys(sources))
+    return ", ".join(unique_sources)
+
+
+def _handle(ui: Any, _: str) -> bool:
+    config = get_global_config()
+    profile = get_profile_for_pointer("main")
+    memory_files = collect_all_memory_files()
+
+    auth_summary, auth_env_var = _auth_token_display(profile)
+    api_base_summary = _api_base_display(profile)
+    memory_lines = _memory_status_lines(memory_files)
+    setting_sources = _setting_sources_summary(
+        config,
+        profile,
+        memory_files,
+        auth_env_var,
+        ui.safe_mode,
+        ui.verbose,
+        ui.project_path,
+    )
+
+    model_label = profile.model if profile else "Not configured"
+
+    ui.console.print()
+    ui.console.rule()
+    ui.console.print(" Status:\n")
+    ui.console.print(f" Version: {__version__}")
+    ui.console.print(f" Session ID: {ui.session_id}")
+    ui.console.print(f" cwd: {Path.cwd()}")
+    ui.console.print(f" Auth token: {auth_summary}")
+    ui.console.print(f" {api_base_summary}")
+    ui.console.print()
+    ui.console.print(f" Model: {model_label}")
+    ui.console.print(" Memory:")
+    for line in memory_lines:
+        ui.console.print(f"  {line}")
+    ui.console.print(f" Setting sources: {setting_sources}")
+    return True
+
+
+command = SlashCommand(
+    name="status",
+    description="Show session status",
+    handler=_handle,
+)
+
+
+__all__ = ["command"]