ripperdoc 0.2.6__py3-none-any.whl

ripperdoc/cli/commands/tasks_cmd.py

@@ -0,0 +1,278 @@
+"""Slash command to inspect and manage background bash tasks."""
+
+import asyncio
+import textwrap
+
+from rich import box
+from rich.panel import Panel
+from rich.table import Table
+from rich.markup import escape
+
+from ripperdoc.tools.background_shell import (
+    get_background_status,
+    kill_background_task,
+    list_background_tasks,
+)
+from ripperdoc.utils.log import get_logger
+
+from typing import Any, Optional
+from .base import SlashCommand
+
+
+logger = get_logger()
+
+
+def _format_duration(duration_ms: Optional[float]) -> str:
+    """Render milliseconds into a short human-readable duration."""
+    if duration_ms is None:
+        return "-"
+    try:
+        duration = float(duration_ms)
+    except (TypeError, ValueError):
+        return "-"
+    if duration < 1000:
+        return f"{int(duration)} ms"
+    seconds = duration / 1000.0
+    if seconds < 60:
+        return f"{seconds:.1f}s"
+    minutes, secs = divmod(int(seconds), 60)
+    if minutes < 60:
+        return f"{minutes}m {secs}s"
+    hours, mins = divmod(minutes, 60)
+    return f"{hours}h {mins}m"
+
+
+def _format_status(status: dict) -> str:
+    """Return a colored status label with exit codes when available."""
+    state = status.get("status") or "unknown"
+    if status.get("timed_out"):
+        state = "failed"
+    if status.get("killed"):
+        state = "killed"
+
+    exit_code = status.get("exit_code")
+    label = state
+    if exit_code is not None and state not in ("running", "killed"):
+        label = f"{label} ({exit_code})"
+
+    color = {
+        "running": "yellow",
+        "completed": "green",
+        "failed": "red",
+        "killed": "red",
+    }.get(state)
+    return f"[{color}]{label}[/{color}]" if color else label
+
+
+def _tail_lines(text: str, max_lines: int = 20, max_chars: int = 4000) -> str:
+    """Return a shortened view of output for display."""
+    if not text:
+        return ""
+
+    lines = text.splitlines()
+    prefixes = []
+
+    if len(lines) > max_lines:
+        lines = lines[-max_lines:]
+        prefixes.append(f"[dim]... showing last {max_lines} lines[/dim]")
+
+    content = "\n".join(lines)
+    if len(content) > max_chars:
+        content = content[-max_chars:]
+        prefixes.insert(0, f"[dim]... output truncated to last {max_chars} chars[/dim]")
+
+    if prefixes:
+        return "\n".join(prefixes + [content])
+    return content
+
+
+def _list_tasks(ui: Any) -> bool:
+    console = ui.console
+    task_ids = list_background_tasks()
+
+    if not task_ids:
+        console.print(
+            Panel("No tasks currently running", title="Background tasks", box=box.ROUNDED)
+        )
+        return True
+
+    table = Table(box=box.SIMPLE_HEAVY, expand=True)
+    table.add_column("ID", style="cyan", no_wrap=True)
+    table.add_column("Status", style="magenta", no_wrap=True)
+    table.add_column("Command", style="white")
+    table.add_column("Duration", style="dim", no_wrap=True)
+
+    for task_id in sorted(task_ids):
+        try:
+            status = get_background_status(task_id, consume=False)
+        except (KeyError, ValueError, RuntimeError, OSError) as exc:
+            table.add_row(escape(task_id), "[red]error[/]", escape(str(exc)), "-")
+            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
+
+        command = status.get("command") or ""
+        command_display = textwrap.shorten(command, width=80, placeholder="...")
+        table.add_row(
+            escape(task_id),
+            _format_status(status),
+            escape(command_display),
+            _format_duration(status.get("duration_ms")),
+        )
+
+    console.print(
+        Panel(
+            table,
+            title="Background tasks",
+            box=box.ROUNDED,
+            padding=(1, 2),
+        )
+    )
+    console.print(
+        "[dim]Use /tasks show <id> to view details/output, /tasks kill <id> to stop a task, or BashOutput/KillBash tools directly.[/dim]"
+    )
+    return True
+
+
+def _kill_task(ui: Any, task_id: str) -> bool:
+    console = ui.console
+    try:
+        status = get_background_status(task_id, consume=False)
+    except KeyError:
+        console.print(f"[red]No task found with id '{escape(task_id)}'.[/red]")
+        return True
+    except (ValueError, RuntimeError, OSError) as exc:
+        console.print(f"[red]Failed to read task '{escape(task_id)}': {escape(str(exc))}[/red]")
+        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
+
+    if status.get("status") != "running":
+        console.print(
+            f"[yellow]Task {escape(task_id)} is not running (status: {escape(str(status.get('status')))}).[/yellow]"
+        )
+        return True
+
+    runner = getattr(ui, "run_async", None)
+
+    try:
+        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.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
+
+    if killed:
+        console.print(
+            f"[green]Killed task {escape(task_id)}[/green] — {escape(status.get('command') or '')}",
+        )
+    else:
+        console.print(f"[red]Failed to kill task {escape(task_id)}[/red]")
+    return True
+
+
+def _show_task(ui: Any, task_id: str) -> bool:
+    console = ui.console
+    try:
+        status = get_background_status(task_id, consume=False)
+    except KeyError:
+        console.print(f"[red]No task found with id '{escape(task_id)}'.[/red]")
+        return True
+    except (ValueError, RuntimeError, OSError) as exc:
+        console.print(f"[red]Failed to read task '{escape(task_id)}': {escape(str(exc))}[/red]")
+        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
+
+    details = Table(box=box.SIMPLE_HEAVY, show_header=False)
+    details.add_row("ID", escape(task_id))
+    details.add_row("Status", _format_status(status))
+    details.add_row("Command", escape(status.get("command") or ""))
+    details.add_row("Duration", _format_duration(status.get("duration_ms")))
+    exit_code = status.get("exit_code")
+    details.add_row("Exit code", str(exit_code) if exit_code is not None else "running")
+
+    console.print(
+        Panel(details, title=f"Task {escape(task_id)}", box=box.ROUNDED, padding=(1, 2)),
+        markup=False,
+    )
+
+    stdout_block = _tail_lines(status.get("stdout") or "")
+    stderr_block = _tail_lines(status.get("stderr") or "")
+
+    console.print(
+        Panel(
+            escape(stdout_block) if stdout_block else "[dim]No stdout yet[/dim]",
+            title="stdout (latest)",
+            box=box.SIMPLE,
+            padding=(1, 2),
+        )
+    )
+    console.print(
+        Panel(
+            escape(stderr_block) if stderr_block else "[dim]No stderr yet[/dim]",
+            title="stderr (latest)",
+            box=box.SIMPLE,
+            padding=(1, 2),
+        )
+    )
+    return True
+
+
+def _handle(ui: Any, args: str) -> bool:
+    parts = args.split()
+    logger.info(
+        "[tasks_cmd] Handling /tasks command",
+        extra={
+            "session_id": getattr(ui, "session_id", None),
+            "raw_args": args,
+        },
+    )
+    if not parts:
+        return _list_tasks(ui)
+
+    command = parts[0].lower()
+    if command in {"kill", "stop"}:
+        if len(parts) < 2:
+            ui.console.print("[red]Usage: /tasks kill <task_id>[/red]")
+            return True
+        return _kill_task(ui, parts[1])
+
+    if command in {"show", "info", "view"}:
+        if len(parts) < 2:
+            ui.console.print("[red]Usage: /tasks show <task_id>[/red]")
+            return True
+        return _show_task(ui, parts[1])
+
+    ui.console.print(
+        "[red]Unknown subcommand. Use /tasks, /tasks show <id>, or /tasks kill <id>.[/red]"
+    )
+    return True
+
+
+command = SlashCommand(
+    name="tasks",
+    description="List, inspect, and manage background tasks started with run_in_background",
+    handler=_handle,
+)
+
+
+__all__ = ["command"]

ripperdoc/cli/commands/todos_cmd.py

@@ -0,0 +1,69 @@
+"""Slash command to display stored todos."""
+
+from rich import box
+from rich.panel import Panel
+from rich.markup import escape
+
+from ripperdoc.utils.todo import (
+    format_todo_lines,
+    format_todo_summary,
+    get_next_actionable,
+    load_todos,
+)
+
+from typing import Any
+from .base import SlashCommand
+
+
+def _handle(ui: Any, trimmed_arg: str) -> bool:
+    console = ui.console
+    todos = load_todos(ui.project_path)
+    next_only = trimmed_arg.strip().lower() in ("next", "-n", "--next")
+
+    if not todos:
+        console.print("  ⎿  [dim]No todos currently tracked[/]")
+        return True
+
+    if next_only:
+        next_todo = get_next_actionable(todos)
+        if not next_todo:
+            console.print("[yellow]No actionable todos (none pending or in_progress).[/yellow]")
+            return True
+        console.print(
+            Panel(
+                f"{escape(next_todo.content)}\n[id: {escape(next_todo.id)} | {escape(next_todo.status)} | {escape(next_todo.priority)}]",
+                title="Next todo",
+                box=box.ROUNDED,
+            )
+        )
+        return True
+
+    summary = escape(format_todo_summary(todos))
+    lines = [escape(line) for line in format_todo_lines(todos)]
+    body = "\n".join(lines)
+    panel = Panel(
+        body or "No todos currently tracked",
+        title="Todos",
+        subtitle=summary,
+        box=box.ROUNDED,
+        padding=(1, 2),
+    )
+    console.print(panel)
+
+    next_todo = get_next_actionable(todos)
+    if next_todo:
+        console.print(
+            f"[dim]Next: {escape(next_todo.content)} (id: {escape(next_todo.id)}, status: {escape(next_todo.status)})[/dim]"
+        )
+    return True
+
+
+command = SlashCommand(
+    name="todos",
+    description="Show the stored todo list for this project",
+    handler=_handle,
+    aliases=(),
+)
+
+
+__all__ = ["command"]

ripperdoc/cli/commands/tools_cmd.py

@@ -0,0 +1,19 @@
+from typing import Any
+from .base import SlashCommand
+
+
+def _handle(ui: Any, _: str) -> bool:
+    ui.console.print("\n[bold]Available Tools:[/bold]")
+    for tool in ui.get_default_tools():
+        ui.console.print(f"  • {tool.name}")
+    return True
+
+
+command = SlashCommand(
+    name="tools",
+    description="List available tools",
+    handler=_handle,
+)
+
+
+__all__ = ["command"]

ripperdoc/cli/ui/__init__.py

@@ -0,0 +1 @@
+"""UI components for the Ripperdoc CLI."""

ripperdoc/cli/ui/context_display.py

@@ -0,0 +1,298 @@
+"""Shared helpers for rendering context/token usage in CLI output."""
+
+from __future__ import annotations
+
+import re
+from typing import Any, Dict, List, Optional, Tuple
+
+from ripperdoc.utils.message_compaction import ContextBreakdown
+
+
+def format_tokens(tokens: int) -> str:
+    """Render token counts in a compact human-readable form."""
+    if tokens >= 1_000_000:
+        value = tokens / 1_000_000
+        suffix = "M"
+    elif tokens >= 1_000:
+        value = tokens / 1_000
+        suffix = "k"
+    else:
+        return str(tokens)
+    text = f"{value:.1f}"
+    if text.endswith(".0"):
+        text = text[:-2]
+    return f"{text}{suffix}"
+
+
+def styled_symbol(symbol: str, color: str) -> str:
+    return f"[{color}]{symbol}[/]"
+
+
+def visible_length(text: str) -> int:
+    """Best-effort length calculation that ignores Rich markup."""
+    if not text:
+        return 0
+    return len(re.sub(r"\[/?[^\]]+\]", "", text))
+
+
+def make_icon_bar(
+    used_tokens: int,
+    reserved_tokens: int,
+    max_tokens: int,
+    *,
+    segments: int = 10,
+    glyph_used: str = "⛁",
+    glyph_partial: str = "⛀",
+    glyph_reserved: str = "⛝",
+    glyph_empty: str = "⛶",
+    color_used: Optional[str] = None,
+    color_reserved: Optional[str] = None,
+    color_empty: Optional[str] = "grey50",
+) -> str:
+    """Render a segmented bar using contextual glyphs."""
+    if max_tokens <= 0:
+        max_tokens = 1
+
+    used_tokens = max(0, min(used_tokens, max_tokens))
+    reserved_tokens = max(0, min(reserved_tokens, max_tokens - used_tokens))
+
+    def style(symbol: str, color: Optional[str]) -> str:
+        return f"[{color}]{symbol}[/]" if color else symbol
+
+    bar: List[str] = []
+    used_slots_float = (used_tokens / max_tokens) * segments
+    used_full = int(used_slots_float)
+    used_partial = used_slots_float - used_full
+    bar.extend([style(glyph_used, color_used)] * min(used_full, segments))
+    if used_partial > 0.05 and len(bar) < segments:
+        bar.append(style(glyph_partial, color_used))
+
+    reserved_slots_float = (reserved_tokens / max_tokens) * segments
+    reserved_full = int(reserved_slots_float)
+    reserved_partial = reserved_slots_float - reserved_full
+    remaining = segments - len(bar)
+    if remaining > 0:
+        bar.extend([style(glyph_reserved, color_reserved)] * min(reserved_full, remaining))
+    remaining = segments - len(bar)
+    if reserved_partial > 0.05 and remaining > 0:
+        bar.append(style(glyph_reserved, color_reserved))
+
+    remaining = segments - len(bar)
+    if remaining > 0:
+        bar.extend([style(glyph_empty, color_empty)] * remaining)
+
+    return " ".join(bar[:segments])
+
+
+def make_segment_grid(
+    breakdown: ContextBreakdown,
+    *,
+    per_row: int = 10,
+) -> List[str]:
+    """Build a 10x10 proportional grid (left→right for main sections, reserved pinned to bottom-right)."""
+    total_slots = max(1, per_row * per_row)  # default 100 slots
+
+    categories: List[Dict[str, Any]] = [
+        {
+            "label": "System prompt",
+            "glyph": "⛁",
+            "color": "grey58",
+            "tokens": breakdown.system_prompt_tokens,
+        },
+        {
+            "label": "MCP instructions",
+            "glyph": "⛁",
+            "color": "cyan",
+            "tokens": getattr(breakdown, "mcp_tokens", 0),
+        },
+        {
+            "label": "System tools",
+            "glyph": "⛁",
+            "color": "green3",
+            "tokens": breakdown.tool_schema_tokens,
+        },
+        {
+            "label": "Memory files",
+            "glyph": "⛁",
+            "color": "dark_orange3",
+            "tokens": breakdown.memory_tokens,
+        },
+        {
+            "label": "Messages",
+            "glyph": "⛁",
+            "color": "medium_purple",
+            "tokens": breakdown.message_tokens,
+        },
+        {
+            "label": "Free space",
+            "glyph": "⛶",
+            "color": "grey46",
+            "tokens": max(breakdown.free_tokens, 0),
+        },
+        {
+            "label": "Autocompact buffer",
+            "glyph": "⛝",
+            "color": "yellow3",
+            "tokens": max(breakdown.reserved_tokens, 0),
+        },
+    ]
+
+    max_tokens = max(breakdown.max_context_tokens, 1)
+
+    # First compute slot counts for all categories so totals match the grid size.
+    allocations: List[int] = []
+    remainders: List[tuple[float, int]] = []
+    allocated = 0
+    for idx, category in enumerate(categories):
+        token_value_int = int(category["tokens"])
+        token_value = max(0, token_value_int)
+        raw_slots = (token_value / max_tokens) * total_slots
+        base = int(raw_slots)
+        if token_value > 0 and base == 0:
+            base = 1  # ensure tiny but nonzero sections are visible
+        allocations.append(base)
+        allocated += base
+        remainders.append((raw_slots - base, idx))
+
+    min_allowed = [1 if int(cat["tokens"]) > 0 else 0 for cat in categories]
+
+    while allocated > total_slots:
+        for _, idx in sorted(remainders, key=lambda x: x[0]):
+            if allocated <= total_slots:
+                break
+            if allocations[idx] > min_allowed[idx]:
+                allocations[idx] -= 1
+                allocated -= 1
+        else:
+            break
+
+    while allocated < total_slots:
+        for _, idx in sorted(remainders, key=lambda x: x[0], reverse=True):
+            if allocated >= total_slots:
+                break
+            allocations[idx] += 1
+            allocated += 1
+        else:
+            break
+
+    # Place all non-reserved sections from the top-left; place reserved from the bottom-right.
+    reserved_count = allocations[-1]
+    forward_categories = categories[:-1]
+    forward_allocations = allocations[:-1]
+
+    icons: List[Optional[str]] = [None] * total_slots
+    cursor = 0
+    for category, count in zip(forward_categories, forward_allocations):
+        for _ in range(count):
+            if cursor >= total_slots:
+                break
+            icons[cursor] = styled_symbol(str(category["glyph"]), str(category["color"]))
+            cursor += 1
+
+    end_cursor = total_slots - 1
+    reserved_symbol = styled_symbol(str(categories[-1]["glyph"]), str(categories[-1]["color"]))
+    for _ in range(reserved_count):
+        if end_cursor < 0:
+            break
+        icons[end_cursor] = reserved_symbol
+        end_cursor -= 1
+
+    # Fill any gaps (should not normally happen) with free-space icons.
+    free_symbol = styled_symbol("⛶", "grey46")
+    for idx, value in enumerate(icons):
+        if value is None:
+            icons[idx] = free_symbol
+
+    rows: List[str] = []
+    for start in range(0, total_slots, per_row):
+        row_icons = [icon for icon in icons[start : start + per_row] if icon is not None]
+        rows.append(" ".join(row_icons))
+    return rows
+
+
+def context_usage_lines(
+    breakdown: ContextBreakdown, model_label: str, auto_compact_enabled: bool
+) -> List[str]:
+    """Build a stylized context usage block using a fixed 10x10 grid."""
+    grid_lines: List[str] = []
+    grid_lines.append("  ⎿   Context Usage")
+
+    grid_rows = make_segment_grid(breakdown, per_row=10)
+    if grid_rows:
+        header_row = grid_rows[0]
+        grid_lines.append(
+            f"     {header_row}   {model_label} · "
+            f"{format_tokens(breakdown.effective_tokens)}/"
+            f"{format_tokens(breakdown.max_context_tokens)} tokens "
+            f"({breakdown.percent_used:.1f}%)"
+        )
+        for row in grid_rows[1:]:
+            grid_lines.append(f"     {row}")
+
+    # Textual stats (without additional mini bars).
+    stats: List[Tuple[str, Optional[int], Optional[float]]] = [
+        (
+            f"{styled_symbol('⛁', 'grey58')} System prompt",
+            breakdown.system_prompt_tokens,
+            breakdown.percent_of_limit(breakdown.system_prompt_tokens),
+        ),
+        (
+            f"{styled_symbol('⛁', 'cyan')} MCP instructions",
+            getattr(breakdown, "mcp_tokens", 0),
+            breakdown.percent_of_limit(getattr(breakdown, "mcp_tokens", 0)),
+        ),
+        (
+            f"{styled_symbol('⛁', 'green3')} System tools",
+            breakdown.tool_schema_tokens,
+            breakdown.percent_of_limit(breakdown.tool_schema_tokens),
+        ),
+        (
+            f"{styled_symbol('⛁', 'dark_orange3')} Memory files",
+            breakdown.memory_tokens,
+            breakdown.percent_of_limit(breakdown.memory_tokens),
+        ),
+        (
+            f"{styled_symbol('⛁', 'medium_purple')} Messages",
+            breakdown.message_tokens,
+            breakdown.percent_of_limit(breakdown.message_tokens),
+        ),
+        (
+            f"{styled_symbol('⛶', 'grey46')} Free space",
+            breakdown.free_tokens,
+            breakdown.percent_of_limit(breakdown.free_tokens),
+        ),
+    ]
+
+    reserved_label = f"{styled_symbol('⛝', 'yellow3')} Autocompact buffer"
+    if auto_compact_enabled and breakdown.reserved_tokens:
+        stats.append(
+            (
+                reserved_label,
+                breakdown.reserved_tokens,
+                breakdown.percent_of_limit(breakdown.reserved_tokens),
+            )
+        )
+    else:
+        stats.append((reserved_label, None, None))
+
+    stats_lines: List[str] = []
+    for label, tokens, percent in stats:
+        if tokens is None:
+            stats_lines.append(f"{label}: disabled")
+        else:
+            stats_lines.append(f"{label}: {format_tokens(tokens)} tokens ({percent:.1f}%)")
+
+    total_rows = max(len(grid_lines), len(stats_lines))
+    padded_grid = [""] * (total_rows - len(grid_lines)) + grid_lines
+    padded_stats = [""] * (total_rows - len(stats_lines)) + stats_lines
+
+    combined: List[str] = []
+    for left, right in zip(padded_grid, padded_stats):
+        # left_pad = " " * max(0, grid_width - visible_length(left))
+        left_pad = ""
+        if right:
+            combined.append(f"{left}{left_pad}   {right}")
+        else:
+            combined.append(f"{left}")
+
+    return combined

ripperdoc/cli/ui/helpers.py

@@ -0,0 +1,22 @@
+"""Shared helper functions for the Rich UI."""
+
+from typing import Optional
+
+from ripperdoc.core.config import get_current_model_profile, get_global_config, ModelProfile
+
+
+def get_profile_for_pointer(pointer: str = "main") -> Optional[ModelProfile]:
+    """Return the configured ModelProfile for a logical pointer or default."""
+    profile = get_current_model_profile(pointer)
+    if profile:
+        return profile
+    config = get_global_config()
+    if "default" in config.model_profiles:
+        return config.model_profiles.get("default")
+    if config.model_profiles:
+        first_name = next(iter(config.model_profiles))
+        return config.model_profiles.get(first_name)
+    return None
+
+
+__all__ = ["get_profile_for_pointer"]