ripperdoc 0.1.0__py3-none-any.whl

ripperdoc/__init__.py

@@ -0,0 +1,3 @@
+"""Ripperdoc - AI-powered coding agent."""
+
+__version__ = "0.1.0"

ripperdoc/__main__.py

@@ -0,0 +1,25 @@
+"""
+Ripperdoc - AI-Powered Coding Agent
+
+A Python implementation of an AI coding assistant.
+
+Features:
+- Execute bash commands
+- Read and edit files
+- Search code with glob and grep
+- AI-powered code assistance
+- Multi-model support
+
+Quick Start:
+    pip install -e .
+    ripperdoc -p "your prompt here"
+
+For more information:
+    - README.md: Project overview
+    - QUICKSTART.md: Quick start guide
+    - DEVELOPMENT.md: Development guide
+"""
+
+from ripperdoc import __version__
+
+__all__ = ["__version__"]

ripperdoc/cli/__init__.py

@@ -0,0 +1 @@
+"""CLI interface for Ripperdoc."""

ripperdoc/cli/cli.py

@@ -0,0 +1,317 @@
+"""Main CLI entry point for Ripperdoc.
+
+This module provides the command-line interface for the Ripperdoc agent.
+"""
+
+import asyncio
+import click
+import sys
+from pathlib import Path
+from typing import Optional
+
+from ripperdoc import __version__
+from ripperdoc.core.config import (
+    get_global_config,
+    save_global_config,
+    get_project_config,
+    ModelProfile,
+    ProviderType,
+)
+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.utils.messages import create_user_message
+from ripperdoc.utils.memory import build_memory_instructions
+from ripperdoc.core.permissions import make_permission_checker
+from ripperdoc.utils.mcp import (
+    load_mcp_servers_async,
+    format_mcp_instructions,
+    shutdown_mcp_runtime,
+)
+from ripperdoc.tools.mcp_tools import load_dynamic_mcp_tools_async, merge_tools_with_dynamic
+
+from rich.console import Console
+from rich.markdown import Markdown
+from rich.panel import Panel
+from rich.markup import escape
+
+console = Console()
+
+
+async def run_query(
+    prompt: str, tools: list, safe_mode: bool = False, verbose: bool = False
+) -> None:
+    """Run a single query and print the response."""
+
+    project_path = Path.cwd()
+    can_use_tool = make_permission_checker(project_path, safe_mode) if safe_mode else None
+
+    # Create initial user message
+    messages = [create_user_message(prompt)]
+
+    # Create query context
+    query_context = QueryContext(tools=tools, safe_mode=safe_mode, verbose=verbose)
+
+    try:
+        context = {}
+        # System prompt
+        servers = await load_mcp_servers_async(Path.cwd())
+        dynamic_tools = await load_dynamic_mcp_tools_async(Path.cwd())
+        if dynamic_tools:
+            tools = merge_tools_with_dynamic(tools, dynamic_tools)
+            query_context.tools = tools
+        mcp_instructions = format_mcp_instructions(servers)
+        base_system_prompt = build_system_prompt(
+            tools,
+            prompt,
+            context,
+            mcp_instructions=mcp_instructions,
+        )
+        memory_instructions = build_memory_instructions()
+        system_prompt = (
+            f"{base_system_prompt}\n\n{memory_instructions}"
+            if memory_instructions
+            else base_system_prompt
+        )
+
+        # Run the query
+        try:
+            async for message in query(
+                messages, system_prompt, context, query_context, can_use_tool
+            ):
+                if message.type == "assistant":
+                    # Print assistant message
+                    if isinstance(message.message.content, str):
+                        console.print(
+                            Panel(
+                                Markdown(message.message.content),
+                                title="Ripperdoc",
+                                border_style="cyan",
+                            )
+                        )
+                    else:
+                        # Handle structured content
+                        for block in message.message.content:
+                            if isinstance(block, dict):
+                                if block.get("type") == "text":
+                                    console.print(
+                                        Panel(
+                                            Markdown(block["text"]),
+                                            title="Ripperdoc",
+                                            border_style="cyan",
+                                        )
+                                    )
+                            else:
+                                if hasattr(block, "type") and block.type == "text":
+                                    console.print(
+                                        Panel(
+                                            Markdown(block.text),
+                                            title="Ripperdoc",
+                                            border_style="cyan",
+                                        )
+                                    )
+
+                elif message.type == "progress":
+                    # Print progress
+                    if verbose:
+                        console.print(f"[dim]Progress: {escape(str(message.content))}[/dim]")
+
+                # Add message to history
+                messages.append(message)
+
+        except KeyboardInterrupt:
+            console.print("\n[yellow]Interrupted by user[/yellow]")
+        except Exception as e:
+            console.print(f"[red]Error: {escape(str(e))}[/red]")
+            if verbose:
+                import traceback
+
+                console.print(traceback.format_exc(), markup=False)
+    finally:
+        await shutdown_mcp_runtime()
+
+
+def check_onboarding() -> bool:
+    """Check if onboarding is complete and run if needed."""
+    config = get_global_config()
+
+    if config.has_completed_onboarding:
+        return True
+
+    console.print("[bold cyan]Welcome to Ripperdoc![/bold cyan]\n")
+    console.print("Let's set up your AI model configuration.\n")
+
+    # Simple onboarding
+    provider_choices = [
+        *[p.value for p in ProviderType],
+        "openai",
+        "deepseek",
+        "mistral",
+        "kimi",
+        "qwen",
+        "glm",
+        "custom",
+    ]
+    provider_choice = click.prompt(
+        "Choose your model protocol",
+        type=click.Choice(provider_choices),
+        default=ProviderType.ANTHROPIC.value,
+    )
+
+    api_base = None
+    if provider_choice == "custom":
+        provider_choice = click.prompt(
+            "Protocol family (for API compatibility)",
+            type=click.Choice([p.value for p in ProviderType]),
+            default=ProviderType.OPENAI_COMPATIBLE.value,
+        )
+        api_base = click.prompt("API Base URL")
+
+    api_key = click.prompt("Enter your API key", hide_input=True)
+
+    provider = ProviderType(provider_choice)
+
+    # Get model name
+    if provider == ProviderType.ANTHROPIC:
+        model = click.prompt("Model name", default="claude-3-5-sonnet-20241022")
+    elif provider == ProviderType.OPENAI_COMPATIBLE:
+        default_model = "gpt-4o-mini"
+        if provider_choice == "deepseek":
+            default_model = "deepseek-chat"
+            api_base = api_base or "https://api.deepseek.com"
+        model = click.prompt("Model name", default=default_model)
+        if api_base is None:
+            api_base = (
+                click.prompt("API base URL (optional)", default="", show_default=False) or None
+            )
+    elif provider == ProviderType.GEMINI:
+        console.print(
+            "[yellow]Gemini protocol support is not yet available; configuration is saved for "
+            "future support.[/yellow]"
+        )
+        model = click.prompt("Model name", default="gemini-1.5-pro")
+        if api_base is None:
+            api_base = (
+                click.prompt("API base URL (optional)", default="", show_default=False) or None
+            )
+    else:
+        model = click.prompt("Model name")
+
+    context_window_input = click.prompt(
+        "Context window in tokens (optional, press Enter to skip)", default="", show_default=False
+    )
+    context_window = None
+    if context_window_input.strip():
+        try:
+            context_window = int(context_window_input.strip())
+        except ValueError:
+            console.print("[yellow]Invalid context window, using auto-detected defaults.[/yellow]")
+
+    # Create model profile
+    config.model_profiles["default"] = ModelProfile(
+        provider=provider,
+        model=model,
+        api_key=api_key,
+        api_base=api_base,
+        context_window=context_window,
+    )
+
+    config.has_completed_onboarding = True
+    config.last_onboarding_version = __version__
+
+    save_global_config(config)
+
+    console.print("\n[green]✓ Configuration saved![/green]\n")
+
+    return True
+
+
+@click.group(invoke_without_command=True)
+@click.version_option(version=__version__)
+@click.option("--cwd", type=click.Path(exists=True), help="Working directory")
+@click.option(
+    "--unsafe",
+    is_flag=True,
+    help="Disable safe mode (skip permission prompts for tools)",
+)
+@click.option("--verbose", is_flag=True, help="Verbose output")
+@click.option("-p", "--prompt", type=str, help="Direct prompt (non-interactive)")
+@click.pass_context
+def cli(
+    ctx: click.Context, cwd: Optional[str], unsafe: bool, verbose: bool, prompt: Optional[str]
+) -> None:
+    """Ripperdoc - AI-powered coding agent"""
+
+    # Ensure onboarding is complete
+    if not check_onboarding():
+        sys.exit(1)
+
+    # Set working directory
+    if cwd:
+        import os
+
+        os.chdir(cwd)
+
+    # Initialize project configuration for the current working directory
+    project_path = Path.cwd()
+    get_project_config(project_path)
+
+    safe_mode = not unsafe
+
+    # If prompt is provided, run directly
+    if prompt:
+        tools = get_default_tools()
+        asyncio.run(run_query(prompt, tools, safe_mode, verbose))
+        return
+
+    # If no command specified, start interactive REPL with Rich interface
+    if ctx.invoked_subcommand is None:
+        # Use Rich interface by default
+        from ripperdoc.cli.ui.rich_ui import main_rich
+
+        main_rich(safe_mode=safe_mode, verbose=verbose)
+        return
+
+
+@cli.command(name="config")
+def config_cmd() -> None:
+    """Show current configuration"""
+    config = get_global_config()
+
+    console.print("\n[bold]Global Configuration[/bold]\n")
+    console.print(f"Version: {__version__}")
+    console.print(f"Onboarding Complete: {config.has_completed_onboarding}")
+    console.print(f"Theme: {config.theme}")
+    console.print(f"Verbose: {config.verbose}")
+    console.print(f"Safe Mode: {config.safe_mode}\n")
+
+    if config.model_profiles:
+        console.print("[bold]Model Profiles:[/bold]")
+        for name, profile in config.model_profiles.items():
+            console.print(f"  {name}:")
+            console.print(f"    Provider: {profile.provider}")
+            console.print(f"    Model: {profile.model}")
+            console.print(f"    API Key: {'***' if profile.api_key else 'Not set'}")
+        console.print()
+
+
+@cli.command(name="version")
+def version_cmd() -> None:
+    """Show version information"""
+    console.print(f"Ripperdoc version {__version__}")
+
+
+def main() -> None:
+    """Main entry point."""
+    try:
+        cli()
+    except KeyboardInterrupt:
+        console.print("\n[yellow]Interrupted[/yellow]")
+        sys.exit(130)
+    except Exception as e:
+        console.print(f"[red]Fatal error: {escape(str(e))}[/red]")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

ripperdoc/cli/commands/__init__.py

@@ -0,0 +1,76 @@
+"""Slash command registry."""
+
+from __future__ import annotations
+
+from typing import Dict, List
+
+from .base import SlashCommand
+from .agents_cmd import command as agents_command
+from .clear_cmd import command as clear_command
+from .compact_cmd import command as compact_command
+from .config_cmd import command as config_command
+from .cost_cmd import command as cost_command
+from .context_cmd import command as context_command
+from .exit_cmd import command as exit_command
+from .help_cmd import command as help_command
+from .mcp_cmd import command as mcp_command
+from .models_cmd import command as models_command
+from .resume_cmd import command as resume_command
+from .tasks_cmd import command as tasks_command
+from .status_cmd import command as status_command
+from .todos_cmd import command as todos_command
+from .tools_cmd import command as tools_command
+
+
+def _build_registry(commands: List[SlashCommand]) -> Dict[str, SlashCommand]:
+    """Map command names and aliases to SlashCommand entries."""
+    registry: Dict[str, SlashCommand] = {}
+    for cmd in commands:
+        registry[cmd.name] = cmd
+        for alias in cmd.aliases:
+            registry[alias] = cmd
+    return registry
+
+
+ALL_COMMANDS: List[SlashCommand] = [
+    help_command,
+    clear_command,
+    config_command,
+    tools_command,
+    models_command,
+    exit_command,
+    status_command,
+    tasks_command,
+    todos_command,
+    mcp_command,
+    cost_command,
+    context_command,
+    compact_command,
+    resume_command,
+    agents_command,
+]
+
+COMMAND_REGISTRY: Dict[str, SlashCommand] = _build_registry(ALL_COMMANDS)
+
+
+def list_slash_commands() -> List[SlashCommand]:
+    """Return the ordered list of base slash commands (no aliases)."""
+    return ALL_COMMANDS
+
+
+def get_slash_command(name: str) -> SlashCommand | None:
+    """Return a command by name or alias."""
+    return COMMAND_REGISTRY.get(name)
+
+
+def slash_command_completions() -> List[tuple[str, SlashCommand]]:
+    """Return (name, command) pairs for completion including aliases."""
+    return list(COMMAND_REGISTRY.items())
+
+
+__all__ = [
+    "SlashCommand",
+    "list_slash_commands",
+    "get_slash_command",
+    "slash_command_completions",
+]

ripperdoc/cli/commands/agents_cmd.py

@@ -0,0 +1,234 @@
+from rich.markup import escape
+
+from ripperdoc.core.agents import (
+    AGENT_DIR_NAME,
+    AgentLocation,
+    delete_agent_definition,
+    load_agent_definitions,
+    save_agent_definition,
+)
+from ripperdoc.core.config import get_global_config
+
+from typing import Any
+from .base import SlashCommand
+
+
+def _handle(ui: Any, trimmed_arg: str) -> bool:
+    console = ui.console
+    tokens = trimmed_arg.split()
+    subcmd = tokens[0].lower() if tokens else ""
+
+    def print_agents_usage() -> None:
+        console.print("[bold]/agents[/bold] — list configured agents")
+        console.print(
+            "[bold]/agents create <name> [location] [model][/bold] — create agent (location: user|project, default user)"
+        )
+        console.print("[bold]/agents edit <name> [location][/bold] — edit an existing agent")
+        console.print(
+            "[bold]/agents delete <name> [location][/bold] — delete agent (location: user|project, default user)"
+        )
+        console.print(
+            f"[dim]Agent files live in ~/.ripperdoc/{AGENT_DIR_NAME} or ./.ripperdoc/{AGENT_DIR_NAME}[/dim]"
+        )
+        console.print(
+            "[dim]Model can be a profile name or pointer (task/main/etc). Defaults to 'task'.[/dim]"
+        )
+
+    if subcmd in ("help", "-h", "--help"):
+        print_agents_usage()
+        return True
+
+    if subcmd in ("create", "add"):
+        agent_name = tokens[1] if len(tokens) > 1 else console.input("Agent name: ").strip()
+        if not agent_name:
+            console.print("[red]Agent name is required.[/red]")
+            print_agents_usage()
+            return True
+
+        description = console.input("Description (when to use this agent): ").strip()
+        if not description:
+            console.print("[red]Description is required.[/red]")
+            return True
+
+        tools_input = console.input("Tools (comma-separated, * for all) [*]: ").strip() or "*"
+        tools = [t.strip() for t in tools_input.split(",") if t.strip()] or ["*"]
+
+        system_prompt = console.input("System prompt (single line, use \\n for newlines): ").strip()
+        if not system_prompt:
+            console.print("[red]System prompt is required.[/red]")
+            print_agents_usage()
+            return True
+
+        location_arg = tokens[2] if len(tokens) > 2 else ""
+        model_arg = tokens[3] if len(tokens) > 3 else ""
+        if location_arg and location_arg.lower() not in ("user", "project"):
+            model_arg, location_arg = location_arg, ""
+
+        location_raw = (
+            location_arg or console.input("Location [user/project, default user]: ").strip()
+        ).lower()
+        location = AgentLocation.PROJECT if location_raw == "project" else AgentLocation.USER
+
+        config = get_global_config()
+        pointer_map = config.model_pointers.model_dump()
+        default_model_value = model_arg or pointer_map.get("task", "task")
+        model_input = (
+            console.input(f"Model profile or pointer [{default_model_value}]: ").strip()
+            or default_model_value
+        )
+        if (
+            model_input
+            and model_input not in config.model_profiles
+            and model_input not in pointer_map
+        ):
+            console.print(
+                "[yellow]Model not found in profiles or pointers; will fall back to main if unavailable.[/yellow]"
+            )
+
+        try:
+            path = save_agent_definition(
+                agent_type=agent_name,
+                description=description,
+                tools=tools,
+                system_prompt=system_prompt,
+                location=location,
+                model=model_input,
+            )
+            console.print(
+                f"[green]✓ Agent '{escape(agent_name)}' created at {escape(str(path))}[/green]"
+            )
+        except Exception as exc:
+            console.print(f"[red]Failed to create agent: {escape(str(exc))}[/red]")
+            print_agents_usage()
+        return True
+
+    if subcmd in ("delete", "del", "remove"):
+        agent_name = (
+            tokens[1] if len(tokens) > 1 else console.input("Agent name to delete: ").strip()
+        )
+        if not agent_name:
+            console.print("[red]Agent name is required.[/red]")
+            print_agents_usage()
+            return True
+
+        location_raw = (
+            tokens[2]
+            if len(tokens) > 2
+            else console.input("Location to delete from [user/project, default user]: ").strip()
+        ).lower()
+        location = AgentLocation.PROJECT if location_raw == "project" else AgentLocation.USER
+        try:
+            path = delete_agent_definition(agent_name, location)
+            console.print(
+                f"[green]✓ Deleted agent '{escape(agent_name)}' at {escape(str(path))}[/green]"
+            )
+        except FileNotFoundError as exc:
+            console.print(f"[yellow]{escape(str(exc))}[/yellow]")
+        except Exception as exc:
+            console.print(f"[red]Failed to delete agent: {escape(str(exc))}[/red]")
+            print_agents_usage()
+        return True
+
+    if subcmd in ("edit", "update"):
+        agent_name = tokens[1] if len(tokens) > 1 else console.input("Agent to edit: ").strip()
+        if not agent_name:
+            console.print("[red]Agent name is required.[/red]")
+            print_agents_usage()
+            return True
+
+        agents = load_agent_definitions()
+        target_agent = next((a for a in agents.active_agents if a.agent_type == agent_name), None)
+        if not target_agent:
+            console.print(f"[red]Agent '{escape(agent_name)}' not found.[/red]")
+            print_agents_usage()
+            return True
+        if target_agent.location == AgentLocation.BUILT_IN:
+            console.print("[yellow]Built-in agents cannot be edited.[/yellow]")
+            return True
+
+        default_location = target_agent.location
+        location_raw = (
+            tokens[2]
+            if len(tokens) > 2
+            else console.input(
+                f"Location to save [user/project, default {default_location.value}]: "
+            ).strip()
+        ).lower()
+        location = AgentLocation.PROJECT if location_raw == "project" else AgentLocation.USER
+
+        description = (
+            console.input(f"Description (when to use) [{target_agent.when_to_use}]: ").strip()
+            or target_agent.when_to_use
+        )
+
+        tools_default = "*" if "*" in target_agent.tools else ", ".join(target_agent.tools)
+        tools_input = (
+            console.input(f"Tools (comma-separated, * for all) [{tools_default}]: ").strip()
+            or tools_default
+        )
+        tools = [t.strip() for t in tools_input.split(",") if t.strip()] or ["*"]
+
+        console.print("[dim]Current system prompt:[/dim]")
+        console.print(escape(target_agent.system_prompt or "(empty)"), markup=False)
+        system_prompt = (
+            console.input(
+                "System prompt (single line, use \\n for newlines) " "[Enter to keep current]: "
+            ).strip()
+            or target_agent.system_prompt
+        )
+
+        config = get_global_config()
+        pointer_map = config.model_pointers.model_dump()
+        model_default = target_agent.model or pointer_map.get("task", "task")
+        model_input = (
+            console.input(f"Model profile or pointer [{model_default}]: ").strip() or model_default
+        )
+
+        try:
+            path = save_agent_definition(
+                agent_type=agent_name,
+                description=description,
+                tools=tools,
+                system_prompt=system_prompt,
+                location=location,
+                model=model_input,
+                overwrite=True,
+            )
+            console.print(
+                f"[green]✓ Agent '{escape(agent_name)}' updated at {escape(str(path))}[/green]"
+            )
+        except Exception as exc:
+            console.print(f"[red]Failed to update agent: {escape(str(exc))}[/red]")
+            print_agents_usage()
+        return True
+
+    agents = load_agent_definitions()
+    console.print("\n[bold]Agents:[/bold]")
+    print_agents_usage()
+    if not agents.active_agents:
+        console.print("  • None configured")
+    for agent in agents.active_agents:
+        location = getattr(agent.location, "value", agent.location)
+        tools_str = "all tools" if "*" in agent.tools else ", ".join(agent.tools)
+        console.print(f"  • {escape(agent.agent_type)} ({escape(str(location))})", markup=False)
+        console.print(f"      {escape(agent.when_to_use)}", markup=False)
+        console.print(f"      tools: {escape(tools_str)}", markup=False)
+        console.print(f"      model: {escape(agent.model or 'task (default)')}", markup=False)
+    if agents.failed_files:
+        console.print("[yellow]Some agent files could not be loaded:[/yellow]")
+        for path, error in agents.failed_files:
+            console.print(f"  - {escape(str(path))}: {escape(str(error))}", markup=False)
+    console.print(
+        f"[dim]Add agents in ~/.ripperdoc/{AGENT_DIR_NAME} or ./.ripperdoc/{AGENT_DIR_NAME}[/dim]"
+    )
+    return True
+
+
+command = SlashCommand(
+    name="agents",
+    description="Manage subagents: list/create/delete",
+    handler=_handle,
+)
+
+
+__all__ = ["command"]

ripperdoc/cli/commands/base.py

@@ -0,0 +1,19 @@
+"""Shared types for slash command handlers."""
+
+from dataclasses import dataclass
+from typing import Any, Callable, Tuple
+
+Handler = Callable[[Any, str], bool]
+
+
+@dataclass(frozen=True)
+class SlashCommand:
+    """A single slash command implementation."""
+
+    name: str
+    description: str
+    handler: Handler
+    aliases: Tuple[str, ...] = ()
+
+
+__all__ = ["SlashCommand", "Handler"]

ripperdoc/cli/commands/clear_cmd.py

@@ -0,0 +1,18 @@
+from typing import Any
+from .base import SlashCommand
+
+
+def _handle(ui: Any, _: str) -> bool:
+    ui.conversation_messages = []
+    ui.console.print("[green]✓ Conversation cleared[/green]")
+    return True
+
+
+command = SlashCommand(
+    name="clear",
+    description="Clear conversation history",
+    handler=_handle,
+)
+
+
+__all__ = ["command"]