ripperdoc 0.1.0__py3-none-any.whl

ripperdoc/cli/commands/compact_cmd.py

@@ -0,0 +1,19 @@
+import asyncio
+
+from typing import Any
+from .base import SlashCommand
+
+
+def _handle(ui: Any, trimmed_arg: str) -> bool:
+    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,114 @@
+import asyncio
+import json
+
+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.utils.memory import build_memory_instructions
+from ripperdoc.utils.message_compaction import (
+    estimate_tokens_from_text,
+    get_remaining_context_tokens,
+    resolve_auto_compact_enabled,
+    summarize_context_usage,
+)
+from ripperdoc.utils.mcp import (
+    estimate_mcp_tokens,
+    format_mcp_instructions,
+    load_mcp_servers_async,
+    shutdown_mcp_runtime,
+)
+
+from typing import Any
+from .base import SlashCommand
+
+
+def _handle(ui: Any, _: str) -> bool:
+    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():
+        try:
+            return await load_mcp_servers_async(ui.project_path)
+        finally:
+            await shutdown_mcp_runtime()
+
+    servers = asyncio.run(_load_servers())
+    mcp_instructions = format_mcp_instructions(servers)
+    base_system_prompt = build_system_prompt(
+        ui.query_context.tools,
+        "",
+        {},
+        mcp_instructions=mcp_instructions,
+    )
+    memory_instructions = build_memory_instructions()
+    memory_tokens = estimate_tokens_from_text(memory_instructions) if memory_instructions else 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_from_text(json.dumps(schema, sort_keys=True))
+                except Exception:
+                    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 Exception:
+        pass
+    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,77 @@
+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
+
+    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 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" f"{'' if stats.requests == 1 else 's'}"
+        if stats.duration_ms:
+            line += f", {_format_duration(stats.duration_ms)} total"
+        line += ")"
+        ui.console.print(line)
+
+    return True
+
+
+command = SlashCommand(
+    name="cost",
+    description="Show total tokens used in this session",
+    handler=_handle,
+)
+
+
+__all__ = ["command"]

ripperdoc/cli/commands/exit_cmd.py

@@ -0,0 +1,19 @@
+from typing import Any
+from .base import SlashCommand
+
+
+def _handle(ui: Any, _: str) -> bool:
+    ui.console.print("[yellow]Goodbye![/yellow]")
+    ui._should_exit = True
+    return True
+
+
+command = SlashCommand(
+    name="exit",
+    description="Exit Ripperdoc",
+    handler=_handle,
+    aliases=("quit",),
+)
+
+
+__all__ = ["command"]

ripperdoc/cli/commands/help_cmd.py

@@ -0,0 +1,20 @@
+from typing import Any
+from .base import SlashCommand
+
+
+def _handle(ui: Any, _: str) -> bool:
+    ui.console.print("\n[bold]Available Slash Commands:[/bold]")
+    for cmd in ui.command_list:
+        alias_text = f" (aliases: {', '.join(cmd.aliases)})" if cmd.aliases else ""
+        ui.console.print(f"  /{cmd.name:<8} - {cmd.description}{alias_text}")
+    return True
+
+
+command = SlashCommand(
+    name="help",
+    description="Show available slash commands",
+    handler=_handle,
+)
+
+
+__all__ = ["command"]

ripperdoc/cli/commands/mcp_cmd.py

@@ -0,0 +1,65 @@
+import asyncio
+
+from rich.markup import escape
+
+from ripperdoc.utils.mcp import load_mcp_servers_async, shutdown_mcp_runtime
+
+from typing import Any
+from .base import SlashCommand
+
+
+def _handle(ui: Any, _: str) -> bool:
+    async def _load() -> list:
+        try:
+            return await load_mcp_servers_async(ui.project_path)
+        finally:
+            await shutdown_mcp_runtime()
+
+    servers = asyncio.run(_load())
+    if not servers:
+        ui.console.print(
+            "[yellow]No MCP servers configured. Add servers to ~/.ripperdoc/mcp.json, ~/.mcp.json, or a project .mcp.json file.[/yellow]"
+        )
+        return True
+
+    ui.console.print("\n[bold]MCP servers[/bold]")
+    for server in servers:
+        status = server.status or "unknown"
+        url_part = f" ({server.url})" if server.url else ""
+        ui.console.print(f"- {server.name}{url_part} — {status}", markup=False)
+        if server.command:
+            cmd_line = " ".join([server.command, *server.args]) if server.args else server.command
+            ui.console.print(f"    Command: {cmd_line}", markup=False)
+        if server.description:
+            ui.console.print(f"    {server.description}", markup=False)
+        if server.error:
+            ui.console.print(f"    [red]Error:[/red] {escape(str(server.error))}")
+        if server.instructions:
+            snippet = server.instructions.strip()
+            if len(snippet) > 160:
+                snippet = snippet[:157] + "..."
+            ui.console.print(f"    Instructions: {snippet}", markup=False)
+        if server.tools:
+            ui.console.print("    Tools:")
+            for tool in server.tools:
+                desc = f" — {tool.description}" if tool.description else ""
+                ui.console.print(f"      • {tool.name}{desc}", markup=False)
+        else:
+            ui.console.print("    Tools: none discovered")
+        if server.resources:
+            ui.console.print(
+                "    Resources: " + ", ".join(res.uri for res in server.resources), markup=False
+            )
+        elif not server.tools:
+            ui.console.print("    Resources: none")
+    return True
+
+
+command = SlashCommand(
+    name="mcp",
+    description="Show configured MCP servers and their tools",
+    handler=_handle,
+)
+
+
+__all__ = ["command"]

ripperdoc/cli/commands/models_cmd.py

@@ -0,0 +1,327 @@
+from typing import Any
+from getpass import getpass
+from typing import Optional
+
+from rich.markup import escape
+
+from ripperdoc.cli.ui.helpers import get_profile_for_pointer
+from ripperdoc.core.config import (
+    ModelProfile,
+    ProviderType,
+    add_model_profile,
+    delete_model_profile,
+    get_global_config,
+    set_model_pointer,
+)
+
+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 ""
+    config = get_global_config()
+
+    def print_models_usage() -> None:
+        console.print("[bold]/models[/bold] — list configured models")
+        console.print("[bold]/models add <name>[/bold] — add or update a model profile")
+        console.print("[bold]/models edit <name>[/bold] — edit an existing model profile")
+        console.print("[bold]/models delete <name>[/bold] — delete a model profile")
+        console.print("[bold]/models use <name>[/bold] — set the main model pointer")
+
+    def parse_int(prompt_text: str, default_value: Optional[int]) -> Optional[int]:
+        raw = console.input(prompt_text).strip()
+        if not raw:
+            return default_value
+        try:
+            return int(raw)
+        except ValueError:
+            console.print("[yellow]Invalid number, keeping previous value.[/yellow]")
+            return default_value
+
+    def parse_float(prompt_text: str, default_value: float) -> float:
+        raw = console.input(prompt_text).strip()
+        if not raw:
+            return default_value
+        try:
+            return float(raw)
+        except ValueError:
+            console.print("[yellow]Invalid number, keeping previous value.[/yellow]")
+            return default_value
+
+    if subcmd in ("help", "-h", "--help"):
+        print_models_usage()
+        return True
+
+    if subcmd in ("add", "create"):
+        profile_name = tokens[1] if len(tokens) > 1 else console.input("Profile name: ").strip()
+        if not profile_name:
+            console.print("[red]Model profile name is required.[/red]")
+            print_models_usage()
+            return True
+
+        overwrite = False
+        existing_profile = config.model_profiles.get(profile_name)
+        if existing_profile:
+            confirm = (
+                console.input(f"Profile '{profile_name}' exists. Overwrite? [y/N]: ")
+                .strip()
+                .lower()
+            )
+            if confirm not in ("y", "yes"):
+                return True
+            overwrite = True
+
+        current_profile = get_profile_for_pointer("main")
+        default_provider = (
+            (current_profile.provider.value) if current_profile else ProviderType.ANTHROPIC.value
+        )
+        provider_input = (
+            console.input(
+                f"Protocol ({', '.join(p.value for p in ProviderType)}) [{default_provider}]: "
+            )
+            .strip()
+            .lower()
+            or default_provider
+        )
+        try:
+            provider = ProviderType(provider_input)
+        except ValueError:
+            console.print(f"[red]Invalid provider: {escape(provider_input)}[/red]")
+            print_models_usage()
+            return True
+
+        default_model = (
+            existing_profile.model
+            if existing_profile
+            else (current_profile.model if current_profile else "")
+        )
+        model_prompt = f"Model name to send{f' [{default_model}]' if default_model else ''}: "
+        model_name = console.input(model_prompt).strip() or default_model
+        if not model_name:
+            console.print("[red]Model name is required.[/red]")
+            return True
+
+        api_key_input = getpass("API key (leave blank to keep unset): ").strip()
+        api_key = api_key_input or (existing_profile.api_key if existing_profile else None)
+
+        api_base_default = existing_profile.api_base if existing_profile else ""
+        api_base = (
+            console.input(
+                f"API base (optional){f' [{api_base_default}]' if api_base_default else ''}: "
+            ).strip()
+            or api_base_default
+            or None
+        )
+
+        max_tokens_default = existing_profile.max_tokens if existing_profile else 4096
+        max_tokens = (
+            parse_int(
+                f"Max output tokens [{max_tokens_default}]: ",
+                max_tokens_default,
+            )
+            or max_tokens_default
+        )
+
+        temp_default = existing_profile.temperature if existing_profile else 0.7
+        temperature = parse_float(
+            f"Temperature [{temp_default}]: ",
+            temp_default,
+        )
+
+        context_window_default = existing_profile.context_window if existing_profile else None
+        context_prompt = "Context window tokens (optional"
+        if context_window_default:
+            context_prompt += f", current {context_window_default}"
+        context_prompt += "): "
+        context_window = parse_int(context_prompt, context_window_default)
+
+        default_set_main = (
+            not config.model_profiles
+            or getattr(config.model_pointers, "main", "") not in config.model_profiles
+        )
+        set_main_input = (
+            console.input(f"Set as main model? [{'Y' if default_set_main else 'y'}/N]: ")
+            .strip()
+            .lower()
+        )
+        set_as_main = set_main_input in ("y", "yes") if set_main_input else default_set_main
+
+        profile = ModelProfile(
+            provider=provider,
+            model=model_name,
+            api_key=api_key,
+            api_base=api_base,
+            max_tokens=max_tokens,
+            temperature=temperature,
+            context_window=context_window,
+        )
+
+        try:
+            add_model_profile(
+                profile_name,
+                profile,
+                overwrite=overwrite,
+                set_as_main=set_as_main,
+            )
+        except Exception as exc:
+            console.print(f"[red]Failed to save model: {escape(str(exc))}[/red]")
+            return True
+
+        marker = " (main)" if set_as_main else ""
+        console.print(f"[green]✓ Model '{escape(profile_name)}' saved{marker}[/green]")
+        return True
+
+    if subcmd in ("edit", "update"):
+        profile_name = tokens[1] if len(tokens) > 1 else console.input("Profile to edit: ").strip()
+        existing_profile = config.model_profiles.get(profile_name or "")
+        if not profile_name or not existing_profile:
+            console.print("[red]Model profile not found.[/red]")
+            print_models_usage()
+            return True
+
+        provider_default = existing_profile.provider.value
+        provider_input = (
+            console.input(
+                f"Protocol ({', '.join(p.value for p in ProviderType)}) [{provider_default}]: "
+            )
+            .strip()
+            .lower()
+            or provider_default
+        )
+        try:
+            provider = ProviderType(provider_input)
+        except ValueError:
+            console.print(f"[red]Invalid provider: {escape(provider_input)}[/red]")
+            return True
+
+        model_name = (
+            console.input(f"Model name to send [{existing_profile.model}]: ").strip()
+            or existing_profile.model
+        )
+
+        api_key_label = "[set]" if existing_profile.api_key else "[not set]"
+        api_key_prompt = f"API key {api_key_label} (Enter=keep, '-'=clear): "
+        api_key_input = getpass(api_key_prompt).strip()
+        if api_key_input == "-":
+            api_key = None
+        elif api_key_input:
+            api_key = api_key_input
+        else:
+            api_key = existing_profile.api_key
+
+        api_base = (
+            console.input(f"API base (optional) [{existing_profile.api_base or ''}]: ").strip()
+            or existing_profile.api_base
+        )
+        if api_base == "":
+            api_base = None
+
+        max_tokens = (
+            parse_int(
+                f"Max output tokens [{existing_profile.max_tokens}]: ",
+                existing_profile.max_tokens,
+            )
+            or existing_profile.max_tokens
+        )
+
+        temperature = parse_float(
+            f"Temperature [{existing_profile.temperature}]: ",
+            existing_profile.temperature,
+        )
+
+        context_window = parse_int(
+            f"Context window tokens [{existing_profile.context_window or 'unset'}]: ",
+            existing_profile.context_window,
+        )
+
+        updated_profile = ModelProfile(
+            provider=provider,
+            model=model_name,
+            api_key=api_key,
+            api_base=api_base,
+            max_tokens=max_tokens,
+            temperature=temperature,
+            context_window=context_window,
+        )
+
+        try:
+            add_model_profile(
+                profile_name,
+                updated_profile,
+                overwrite=True,
+                set_as_main=False,
+            )
+        except Exception as exc:
+            console.print(f"[red]Failed to update model: {escape(str(exc))}[/red]")
+            return True
+
+        console.print(f"[green]✓ Model '{escape(profile_name)}' updated[/green]")
+        return True
+
+    if subcmd in ("delete", "del", "remove"):
+        target = tokens[1] if len(tokens) > 1 else console.input("Model to delete: ").strip()
+        if not target:
+            console.print("[red]Model name is required.[/red]")
+            print_models_usage()
+            return True
+        try:
+            delete_model_profile(target)
+            console.print(f"[green]✓ Deleted model '{escape(target)}'[/green]")
+        except KeyError as exc:
+            console.print(f"[yellow]{escape(str(exc))}[/yellow]")
+        except Exception as exc:
+            console.print(f"[red]Failed to delete model: {escape(str(exc))}[/red]")
+            print_models_usage()
+        return True
+
+    if subcmd in ("use", "main", "set-main"):
+        target = tokens[1] if len(tokens) > 1 else console.input("Model to use as main: ").strip()
+        if not target:
+            console.print("[red]Model name is required.[/red]")
+            print_models_usage()
+            return True
+        try:
+            set_model_pointer("main", target)
+            console.print(f"[green]✓ Main model set to '{escape(target)}'[/green]")
+        except Exception as exc:
+            console.print(f"[red]{escape(str(exc))}[/red]")
+            print_models_usage()
+        return True
+
+    print_models_usage()
+    pointer_map = config.model_pointers.model_dump()
+    if not config.model_profiles:
+        console.print("  • No models configured")
+        return True
+
+    console.print("\n[bold]Configured Models:[/bold]")
+    for name, profile in config.model_profiles.items():
+        markers = [ptr for ptr, value in pointer_map.items() if value == name]
+        marker_text = f" ({', '.join(markers)})" if markers else ""
+        console.print(f"  • {escape(name)}{marker_text}", markup=False)
+        console.print(f"      protocol: {profile.provider.value}", markup=False)
+        console.print(f"      model: {profile.model}", markup=False)
+        if profile.api_base:
+            console.print(f"      api_base: {profile.api_base}", markup=False)
+        if profile.context_window:
+            console.print(f"      context: {profile.context_window} tokens", markup=False)
+        console.print(
+            f"      max_tokens: {profile.max_tokens}, temperature: {profile.temperature}",
+            markup=False,
+        )
+        console.print(f"      api_key: {'***' if profile.api_key else 'Not set'}", markup=False)
+    pointer_labels = ", ".join(f"{p}->{v or '-'}" for p, v in pointer_map.items())
+    console.print(f"[dim]Pointers: {escape(pointer_labels)}[/dim]")
+    return True
+
+
+command = SlashCommand(
+    name="models",
+    description="Manage models: list/create/delete/use",
+    handler=_handle,
+)
+
+
+__all__ = ["command"]