crabcode 0.1.6__py3-none-win_amd64.whl

crabcode_cli/model_picker.py

@@ -0,0 +1,168 @@
+"""Full-screen selection of configured model profiles."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from prompt_toolkit.application import Application
+from prompt_toolkit.buffer import Buffer
+from prompt_toolkit.data_structures import Point
+from prompt_toolkit.filters import Condition
+from prompt_toolkit.key_binding import KeyBindings
+from prompt_toolkit.layout import HSplit, Layout, VSplit, Window
+from prompt_toolkit.layout.controls import BufferControl, FormattedTextControl
+
+from crabcode_cli.session_picker import PICKER_STYLE, _plain
+from crabcode_core.events import CoreSession
+
+
+class ModelPicker:
+    def __init__(self, session: CoreSession) -> None:
+        # The REPL initializes its session lazily. Before the first request,
+        # the configured default is already the effective model profile.
+        self.current_name = getattr(session, "_current_model_name", None) or session.settings.default_model
+        active = session.settings.get_api_config(self.current_name)
+        self.current_label = (
+            f"{self.current_name or 'default'} · {active.provider or 'anthropic'}/"
+            f"{active.model or 'default'} · {active.group or 'default'}"
+        )
+        grouped: dict[str, list[dict[str, str]]] = {}
+        for name, description in session.list_models().items():
+            config = session.settings.get_api_config(name)
+            group = config.group or "default"
+            grouped.setdefault(group, []).append({
+                "name": name, "description": description, "group": group,
+                "provider": config.provider or "anthropic", "model": config.model or "default",
+            })
+        self.rows = [row for rows in grouped.values() for row in rows]
+        self.groups = list(grouped)
+        self.group_index = 0  # Zero means all groups; actual names may also be "All".
+        self.matches = self.rows.copy()
+        self.selected = next((i for i, row in enumerate(self.matches)
+                              if row["name"] == self.current_name), 0)
+        self.query = Buffer(on_text_changed=lambda _: self.refresh())
+        self.search = BufferControl(buffer=self.query)
+        self.group_control = FormattedTextControl(self._group, focusable=True)
+        self.list_window = Window(
+            FormattedTextControl(self._list, get_cursor_position=lambda: Point(0, self._selected_line())),
+            wrap_lines=False, always_hide_cursor=True,
+        )
+        bindings = KeyBindings()
+
+        @bindings.add("escape", eager=True)
+        @bindings.add("c-c", eager=True)
+        @bindings.add("c-d", eager=True)
+        def cancel(event: Any) -> None:
+            event.app.exit(result=None)
+
+        @bindings.add("enter", eager=True)
+        def confirm(event: Any) -> None:
+            if self.matches:
+                event.app.exit(result=self.matches[self.selected]["name"])
+
+        @bindings.add("up")
+        @bindings.add("down")
+        @bindings.add("pageup")
+        @bindings.add("pagedown")
+        def navigate(event: Any) -> None:
+            page = max(1, self.list_window.render_info.window_height - 1) if self.list_window.render_info else 10
+            delta = {"up": -1, "down": 1, "pageup": -page, "pagedown": page}[event.key_sequence[0].key]
+            self.selected = max(0, min(len(self.matches) - 1, self.selected + delta))
+
+        @bindings.add("tab")
+        @bindings.add("s-tab")
+        def focus(event: Any) -> None:
+            event.app.layout.focus(self.search if event.app.layout.has_focus(self.group_control) else self.group_control)
+
+        @bindings.add("left", filter=Condition(lambda: self.app.layout.has_focus(self.group_control)))
+        @bindings.add("right", filter=Condition(lambda: self.app.layout.has_focus(self.group_control)))
+        @bindings.add("space", filter=Condition(lambda: self.app.layout.has_focus(self.group_control)))
+        def change_group(event: Any) -> None:
+            delta = -1 if event.key_sequence[0].key == "left" else 1
+            self.group_index = (self.group_index + delta) % (len(self.groups) + 1)
+            self.refresh()
+
+        self.app: Application[str | None] = Application(
+            layout=Layout(HSplit([
+                Window(FormattedTextControl([("class:accent", "  ╭─ CrabCode · Select model")]), height=1),
+                Window(FormattedTextControl([("class:hint", f"  Current: {_plain(self.current_label)}")]), height=1, wrap_lines=False),
+                Window(height=1),
+                VSplit([
+                    Window(FormattedTextControl([("class:accent", "  Search ❯ ")]), width=11),
+                    Window(self.search, height=1, wrap_lines=False),
+                ], height=1),
+                Window(self.group_control, height=1),
+                Window(height=1),
+                self.list_window,
+                Window(FormattedTextControl(self._details), height=2, wrap_lines=False),
+                Window(char="─", height=1, style="class:hint"),
+                Window(FormattedTextControl(self._footer), height=2, wrap_lines=True),
+            ]), focused_element=self.search),
+            key_bindings=bindings, full_screen=True, erase_when_done=True, style=PICKER_STYLE,
+        )
+
+    def refresh(self) -> None:
+        terms = self.query.text.casefold().split()
+        group = self.groups[self.group_index - 1] if self.group_index else None
+        self.matches = [row for row in self.rows
+                        if (group is None or row["group"] == group)
+                        and all(term in " ".join(row.values()).casefold() for term in terms)]
+        self.selected = next((i for i, row in enumerate(self.matches)
+                              if row["name"] == self.current_name), 0)
+        self.app.invalidate()
+
+    def _group(self) -> list[tuple[str, str]]:
+        focused = self.app.layout.has_focus(self.group_control)
+        group = self.groups[self.group_index - 1] if self.group_index else "All groups"
+        return [("class:focused" if focused else "class:hint", f"  Group: {_plain(group)}")]
+
+    def _list(self) -> list[tuple[str, str]]:
+        if not self.rows:
+            return [("class:hint", "  No named models configured. Add models to settings.json.")]
+        if not self.matches:
+            return [("class:hint", "  No matching models. Clear search or select All groups.")]
+        fragments = []
+        previous_group = None
+        for i, row in enumerate(self.matches):
+            if row["group"] != previous_group:
+                fragments.append(("class:accent", f"  ─ {_plain(row['group'])}\n"))
+                previous_group = row["group"]
+            style = "class:selected" if i == self.selected else ""
+            marker = "  ← active" if row["name"] == self.current_name else ""
+            fragments.extend([
+                (style, "    ❯ " if i == self.selected else "      "),
+                (style, _plain(row["name"]) + marker),
+                (style if i == self.selected else "class:hint",
+                 f"  · {_plain(row['provider'])}/{_plain(row['model'])}"),
+                ("", "\n" if i < len(self.matches) - 1 else ""),
+            ])
+        return fragments
+
+    def _selected_line(self) -> int:
+        # Group headings occupy display lines but are never selectable.
+        headings = 0
+        previous_group = None
+        for row in self.matches[:self.selected + 1]:
+            if row["group"] != previous_group:
+                headings += 1
+                previous_group = row["group"]
+        return self.selected + headings
+
+    def _details(self) -> list[tuple[str, str]]:
+        if not self.matches:
+            return []
+        row = self.matches[self.selected]
+        return [("class:hint", f"  {_plain(row['name'])} · {_plain(row['group'])}\n"
+                 f"  {_plain(row['description'])}")]
+
+    def _footer(self) -> list[tuple[str, str]]:
+        count = len(self.matches)
+        return [("class:hint", f"  ↑↓ browse · PgUp/PgDn page · Enter switch · Esc/Ctrl+C cancel    {self.selected + 1 if count else 0}/{count}\n"
+                 "  Type to search · Tab focus group · ←→ change group")]
+
+    async def run(self) -> str | None:
+        return await self.app.run_async()
+
+
+async def select_model(session: CoreSession) -> str | None:
+    return await ModelPicker(session).run()

crabcode_cli/pipe.py

@@ -0,0 +1,148 @@
+"""Pipe mode — reads from stdin, sends to Core, writes to stdout."""
+
+from __future__ import annotations
+
+import json
+import os
+import sys
+
+from crabcode_core.events import CoreSession
+from crabcode_core.utf8_sanitize import safe_utf8_str
+from crabcode_core.types.config import CrabCodeSettings
+from crabcode_core.types.event import (
+    ChoiceRequestEvent,
+    ChoiceResponseEvent,
+    ErrorEvent,
+    PermissionRequestEvent,
+    PermissionResponseEvent,
+    StreamRetryEvent,
+    StreamTextEvent,
+    ThinkingEvent,
+    ToolResultEvent,
+    ToolUseEvent,
+    TurnCompleteEvent,
+)
+
+_DEBUG_TOOL_PAYLOAD = os.getenv("CRABCODE_DEBUG_TOOL_PAYLOAD", "").strip().lower() in {
+    "1",
+    "true",
+    "yes",
+    "on",
+}
+
+
+def _format_token_count(tokens: int) -> str:
+    if tokens >= 1_000_000:
+        return f"{tokens / 1_000_000:.1f}M"
+    if tokens >= 1_000:
+        return f"{tokens // 1_000}k"
+    return str(tokens)
+
+
+def _format_percent(percent: float) -> str:
+    rounded = round(percent)
+    if abs(percent - rounded) < 0.05:
+        return f"{rounded}%"
+    return f"{percent:.1f}%"
+
+
+def _format_context_usage(event: TurnCompleteEvent) -> str | None:
+    used = max(0, int(getattr(event, "context_used_tokens", 0) or 0))
+    window = max(0, int(getattr(event, "context_window_tokens", 0) or 0))
+    parts: list[str] = []
+    if window:
+        used_percent = max(0.0, float(getattr(event, "context_used_percent", 0.0) or 0.0))
+        remaining_percent = max(0.0, 100.0 - used_percent)
+        parts.append(
+            f"Context: {_format_percent(used_percent)} used "
+            f"({_format_percent(remaining_percent)} remaining) · "
+            f"{_format_token_count(used)} tokens used of {_format_token_count(window)}"
+        )
+    elif used:
+        parts.append(f"Context: {_format_token_count(used)} tokens used (window unknown)")
+
+    usage = event.usage
+    if "cache_read_tokens" in usage or "cache_write_tokens" in usage:
+        cache_read = max(0, int(usage.get("cache_read_tokens", 0) or 0))
+        cache_write = max(0, int(usage.get("cache_write_tokens", 0) or 0))
+        total_input = max(
+            0,
+            int(usage.get("total_input_tokens", usage.get("input_tokens", 0)) or 0),
+        )
+        hit_rate = cache_read / total_input * 100 if total_input else 0.0
+        cache_parts = [
+            f"Cache: {_format_percent(hit_rate)} hit",
+            f"read {_format_token_count(cache_read)}",
+        ]
+        if "cache_write_tokens" in usage:
+            cache_parts.append(f"write {_format_token_count(cache_write)}")
+        parts.append(" · ".join(cache_parts))
+    return " · ".join(parts) or None
+
+
+async def run_pipe(
+    prompt: str,
+    settings: CrabCodeSettings | None = None,
+    cwd: str = ".",
+    images: list[dict[str, str]] | None = None,
+) -> None:
+    """Run a single prompt through the core and print the response."""
+    from crabcode_cli.computer_use import connect_session
+
+    session = CoreSession(cwd=cwd, settings=settings)
+    computer_use = None
+    try:
+        computer_use = await connect_session(session)
+        async for event in session.send_message(prompt, images=images):
+            if isinstance(event, StreamTextEvent):
+                sys.stdout.write(safe_utf8_str(event.text))
+                sys.stdout.flush()
+            elif isinstance(event, ThinkingEvent):
+                pass
+            elif isinstance(event, ToolUseEvent):
+                sys.stderr.write(f"\n[Tool: {event.tool_name}]\n")
+                if _DEBUG_TOOL_PAYLOAD:
+                    pretty = json.dumps(event.tool_input, ensure_ascii=False, indent=2)
+                    sys.stderr.write(f"{pretty}\n")
+                sys.stderr.flush()
+            elif isinstance(event, PermissionRequestEvent):
+                await session.respond_permission(
+                    PermissionResponseEvent(
+                        tool_use_id=event.tool_use_id, allowed=True
+                    )
+                )
+            elif isinstance(event, ChoiceRequestEvent):
+                selected = [event.options[0]] if event.options else []
+                await session.respond_choice(
+                    ChoiceResponseEvent(
+                        tool_use_id=event.tool_use_id,
+                        selected=selected,
+                        cancelled=not bool(selected),
+                    )
+                )
+            elif isinstance(event, ToolResultEvent):
+                if event.is_error:
+                    sys.stderr.write(f"\n[Error: {event.result}]\n")
+                    sys.stderr.flush()
+            elif isinstance(event, StreamRetryEvent):
+                sys.stderr.write(f"\n[↻ {safe_utf8_str(event.message)}]\n")
+                sys.stderr.flush()
+            elif isinstance(event, ErrorEvent):
+                sys.stderr.write(f"\nError: {safe_utf8_str(event.message)}\n")
+                sys.stderr.flush()
+                if not event.recoverable:
+                    sys.exit(1)
+            elif isinstance(event, TurnCompleteEvent):
+                usage_text = _format_context_usage(event)
+                if usage_text:
+                    sys.stderr.write(f"\n{usage_text}\n")
+                    sys.stderr.flush()
+    finally:
+        try:
+            await session.close()
+        finally:
+            if computer_use is not None:
+                await computer_use.close()
+
+    sys.stdout.write("\n")
+    sys.stdout.flush()

crabcode_cli/render/messages.py

@@ -0,0 +1,19 @@
+"""Message rendering utilities for the CLI."""
+
+from __future__ import annotations
+
+from rich.console import Console
+from rich.markdown import Markdown
+from rich.panel import Panel
+
+
+def render_assistant_markdown(text: str, console: Console | None = None) -> None:
+    """Render assistant text as Markdown."""
+    c = console or Console()
+    c.print(Markdown(text))
+
+
+def render_error(message: str, console: Console | None = None) -> None:
+    """Render an error message."""
+    c = console or Console()
+    c.print(Panel(message, title="Error", border_style="red"))