ripperdoc 0.2.6__py3-none-any.whl

ripperdoc/cli/commands/agents_cmd.py

@@ -0,0 +1,263 @@
+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 ripperdoc.utils.log import get_logger
+
+from typing import Any
+from .base import SlashCommand
+
+logger = get_logger()
+
+
+def _handle(ui: Any, trimmed_arg: str) -> bool:
+    console = ui.console
+    tokens = trimmed_arg.split()
+    subcmd = tokens[0].lower() if tokens else ""
+    logger.info(
+        "[agents_cmd] Handling /agents command",
+        extra={
+            "subcommand": subcmd or "list",
+            "session_id": getattr(ui, "session_id", None),
+        },
+    )
+
+    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} "
+            f"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 (OSError, IOError, PermissionError, ValueError) as exc:
+            console.print(f"[red]Failed to create agent: {escape(str(exc))}[/red]")
+            print_agents_usage()
+            logger.warning(
+                "[agents_cmd] Failed to create agent: %s: %s",
+                type(exc).__name__, exc,
+                extra={"agent": agent_name, "session_id": getattr(ui, "session_id", None)},
+            )
+        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 (OSError, IOError, PermissionError, ValueError) as exc:
+            console.print(f"[red]Failed to delete agent: {escape(str(exc))}[/red]")
+            print_agents_usage()
+            logger.warning(
+                "[agents_cmd] Failed to delete agent: %s: %s",
+                type(exc).__name__, exc,
+                extra={"agent": agent_name, "session_id": getattr(ui, "session_id", None)},
+            )
+        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 (OSError, IOError, PermissionError, ValueError) as exc:
+            console.print(f"[red]Failed to update agent: {escape(str(exc))}[/red]")
+            print_agents_usage()
+            logger.warning(
+                "[agents_cmd] Failed to update agent: %s: %s",
+                type(exc).__name__, exc,
+                extra={"agent": agent_name, "session_id": getattr(ui, "session_id", None)},
+            )
+        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"]

ripperdoc/cli/commands/compact_cmd.py

@@ -0,0 +1,23 @@
+from typing import Any
+from .base import SlashCommand
+
+
+def _handle(ui: Any, trimmed_arg: str) -> bool:
+    runner = getattr(ui, "run_async", None)
+    if callable(runner):
+        runner(ui._run_manual_compact(trimmed_arg))
+    else:
+        import asyncio
+
+        asyncio.run(ui._run_manual_compact(trimmed_arg))
+    return True
+
+
+command = SlashCommand(
+    name="compact",
+    description="Compact conversation history",
+    handler=_handle,
+)
+
+
+__all__ = ["command"]

ripperdoc/cli/commands/config_cmd.py

@@ -0,0 +1,31 @@
+from rich.markup import escape
+
+from ripperdoc.core.config import get_global_config
+from ripperdoc.cli.ui.helpers import get_profile_for_pointer
+
+from typing import Any
+from .base import SlashCommand
+
+
+def _handle(ui: Any, _: str) -> bool:
+    config = get_global_config()
+    profile = get_profile_for_pointer("main")
+    main_pointer = getattr(config.model_pointers, "main", "default")
+    model_label = profile.model if profile else "Not configured"
+
+    ui.console.print(
+        f"\n[bold]Model (main -> {escape(str(main_pointer))}):[/bold] {escape(str(model_label))}"
+    )
+    ui.console.print(f"[bold]Safe Mode:[/bold] {escape(str(ui.safe_mode))}")
+    ui.console.print(f"[bold]Verbose:[/bold] {escape(str(ui.verbose))}")
+    return True
+
+
+command = SlashCommand(
+    name="config",
+    description="Show current configuration",
+    handler=_handle,
+)
+
+
+__all__ = ["command"]

ripperdoc/cli/commands/context_cmd.py

@@ -0,0 +1,144 @@
+import json
+from typing import List, Any
+
+from ripperdoc.cli.ui.helpers import get_profile_for_pointer
+from ripperdoc.cli.ui.context_display import format_tokens
+from ripperdoc.core.config import get_global_config, provider_protocol
+from ripperdoc.core.query import QueryContext
+from ripperdoc.core.system_prompt import build_system_prompt
+from ripperdoc.core.skills import build_skill_summary, load_all_skills
+from ripperdoc.utils.memory import build_memory_instructions
+from ripperdoc.utils.message_compaction import (
+    get_remaining_context_tokens,
+    resolve_auto_compact_enabled,
+    summarize_context_usage,
+)
+from ripperdoc.utils.token_estimation import estimate_tokens
+from ripperdoc.utils.mcp import (
+    estimate_mcp_tokens,
+    format_mcp_instructions,
+    load_mcp_servers_async,
+)
+from ripperdoc.utils.log import get_logger
+
+from .base import SlashCommand
+
+logger = get_logger()
+
+
+def _handle(ui: Any, _: str) -> bool:
+    logger.info(
+        "[context_cmd] Rendering context summary",
+        extra={"session_id": getattr(ui, "session_id", None)},
+    )
+    config = get_global_config()
+    model_profile = get_profile_for_pointer("main")
+    max_context_tokens = get_remaining_context_tokens(model_profile, config.context_token_limit)
+    auto_compact_enabled = resolve_auto_compact_enabled(config)
+    protocol = provider_protocol(model_profile.provider) if model_profile else "openai"
+
+    if not ui.query_context:
+        ui.query_context = QueryContext(
+            tools=ui.get_default_tools(),
+            safe_mode=ui.safe_mode,
+            verbose=ui.verbose,
+        )
+
+    async def _load_servers() -> List[Any]:
+        return await load_mcp_servers_async(ui.project_path)
+
+    runner = getattr(ui, "run_async", None)
+    if callable(runner):
+        servers = runner(_load_servers())
+    else:
+        import asyncio
+
+        servers = asyncio.run(_load_servers())
+    mcp_instructions = format_mcp_instructions(servers)
+    skill_result = load_all_skills(ui.project_path)
+    for err in skill_result.errors:
+        logger.warning(
+            "[skills] Failed to load skill",
+            extra={
+                "path": str(err.path),
+                "reason": err.reason,
+                "session_id": getattr(ui, "session_id", None),
+            },
+        )
+    skill_instructions = build_skill_summary(skill_result.skills)
+    additional_instructions: List[str] = []
+    if skill_instructions:
+        additional_instructions.append(skill_instructions)
+    memory_instructions = build_memory_instructions()
+    if memory_instructions:
+        additional_instructions.append(memory_instructions)
+    base_system_prompt = build_system_prompt(
+        ui.query_context.tools,
+        "",
+        {},
+        additional_instructions=additional_instructions or None,
+        mcp_instructions=mcp_instructions,
+    )
+    memory_tokens = 0
+    mcp_tokens = estimate_mcp_tokens(servers) if mcp_instructions else 0
+
+    breakdown = summarize_context_usage(
+        ui.conversation_messages,
+        ui.query_context.tools,
+        base_system_prompt,
+        max_context_tokens,
+        auto_compact_enabled,
+        memory_tokens=memory_tokens,
+        mcp_tokens=mcp_tokens,
+        protocol=protocol,
+    )
+
+    model_label = model_profile.model if model_profile else "Unknown model"
+    lines = ui._context_usage_lines(breakdown, model_label, auto_compact_enabled)
+
+    lines.append("")
+    # Append a brief tool listing so users can see which tools are currently loaded.
+    try:
+        # Detailed MCP tool listing with token estimates.
+        mcp_tools = [
+            tool
+            for tool in getattr(ui.query_context, "tool_registry", ui.query_context).all_tools
+            if getattr(tool, "is_mcp", False) or getattr(tool, "name", "").startswith("mcp__")
+        ]
+        if mcp_tools:
+            lines.append("   MCP tools · /mcp")
+            for tool in mcp_tools[:20]:
+                name = getattr(tool, "name", "unknown")
+                display = name
+                parts = name.split("__")
+                if len(parts) >= 3 and parts[0] == "mcp":
+                    server = parts[1]
+                    display = "__".join(parts[2:])
+                    display = f"{display} ({server})"
+                try:
+                    schema = tool.input_schema.model_json_schema()
+                    token_est = estimate_tokens(json.dumps(schema, sort_keys=True))
+                except (AttributeError, TypeError, ValueError):
+                    token_est = 0
+                lines.append(f"     └ {display}: {format_tokens(token_est)} tokens")
+            if len(mcp_tools) > 20:
+                lines.append(f"     └ ... (+{len(mcp_tools) - 20} more)")
+    except (OSError, RuntimeError, AttributeError, TypeError) as exc:
+        logger.warning(
+            "[context_cmd] Failed to summarize MCP tools: %s: %s",
+            type(exc).__name__, exc,
+            extra={"session_id": getattr(ui, "session_id", None)},
+        )
+    for line in lines:
+        ui.console.print(line)
+    return True
+
+
+command = SlashCommand(
+    name="context",
+    description="Show current conversation context summary",
+    handler=_handle,
+)
+
+
+__all__ = ["command"]

ripperdoc/cli/commands/cost_cmd.py

@@ -0,0 +1,82 @@
+from ripperdoc.utils.session_usage import get_session_usage
+
+from typing import Any
+from .base import SlashCommand
+
+
+def _fmt_tokens(value: int) -> str:
+    """Format integers with thousand separators."""
+    return f"{int(value):,}"
+
+
+def _format_duration(duration_ms: float) -> str:
+    """Render milliseconds into a compact human-readable duration."""
+    seconds = int(duration_ms // 1000)
+    if seconds < 60:
+        return f"{duration_ms / 1000:.2f}s"
+    minutes, secs = divmod(seconds, 60)
+    if minutes < 60:
+        return f"{minutes}m {secs}s"
+    hours, mins = divmod(minutes, 60)
+    return f"{hours}h {mins}m {secs}s"
+
+
+def _handle(ui: Any, _: str) -> bool:
+    usage = get_session_usage()
+    if not usage.models:
+        ui.console.print("[yellow]No model usage recorded yet.[/yellow]")
+        return True
+
+    total_input = usage.total_input_tokens
+    total_output = usage.total_output_tokens
+    total_cache_read = usage.total_cache_read_tokens
+    total_cache_creation = usage.total_cache_creation_tokens
+    total_tokens = total_input + total_output + total_cache_read + total_cache_creation
+    total_cost = usage.total_cost_usd
+
+    ui.console.print("\n[bold]Session token usage[/bold]")
+    ui.console.print(
+        f" Total: {_fmt_tokens(total_tokens)} tokens "
+        f"(input {_fmt_tokens(total_input)}, output {_fmt_tokens(total_output)})"
+    )
+    if total_cache_read or total_cache_creation:
+        ui.console.print(
+            f" Cache: {_fmt_tokens(total_cache_read)} read, "
+            f"{_fmt_tokens(total_cache_creation)} write"
+        )
+    ui.console.print(f" Requests: {usage.total_requests}")
+    if total_cost:
+        ui.console.print(f" Cost: ${total_cost:.4f}")
+    if usage.total_duration_ms:
+        ui.console.print(f" API time: {_format_duration(usage.total_duration_ms)}")
+
+    ui.console.print("\n[bold]By model:[/bold]")
+    for model_name, stats in usage.models.items():
+        line = (
+            f"  {model_name}: "
+            f"{_fmt_tokens(stats.input_tokens)} in, "
+            f"{_fmt_tokens(stats.output_tokens)} out"
+        )
+        if stats.cache_read_input_tokens:
+            line += f", {_fmt_tokens(stats.cache_read_input_tokens)} cache read"
+        if stats.cache_creation_input_tokens:
+            line += f", {_fmt_tokens(stats.cache_creation_input_tokens)} cache write"
+        line += f" ({stats.requests} call{'' if stats.requests == 1 else 's'}"
+        if stats.duration_ms:
+            line += f", {_format_duration(stats.duration_ms)} total"
+        line += ")"
+        if stats.cost_usd:
+            line += f", ${stats.cost_usd:.4f}"
+        ui.console.print(line)
+
+    return True
+
+
+command = SlashCommand(
+    name="cost",
+    description="Show total tokens used in this session",
+    handler=_handle,
+)
+
+
+__all__ = ["command"]