thwip-cli 1.0.0__py3-none-any.whl

thwip/session.py

@@ -0,0 +1,175 @@
+"""
+Session & conversation state manager for thwip.
+
+Enables seamless context portability across agent switches without losing history.
+"""
+
+from __future__ import annotations
+
+import json
+import time
+import uuid
+from dataclasses import asdict, dataclass, field
+from datetime import datetime
+from pathlib import Path
+from typing import Any
+
+from thwip.config import get_sessions_dir
+
+
+@dataclass
+class Message:
+    """A single message in the conversation history."""
+    role: str                       # "user" | "assistant" | "system" | "tool"
+    content: str
+    timestamp: float = field(default_factory=time.time)
+    agent_name: str = ""           # Which agent created this (e.g. "claude")
+    model: str = ""                # Which model (e.g. "claude-sonnet-4")
+    company: str = ""              # e.g. "Anthropic"
+    tool_calls: list[dict[str, Any]] = field(default_factory=list)
+    tokens: int = 0
+
+    def to_dict(self) -> dict[str, Any]:
+        return asdict(self)
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> "Message":
+        return cls(**data)
+
+
+@dataclass
+class Session:
+    """A complete conversation session."""
+    id: str = field(default_factory=lambda: str(uuid.uuid4())[:8])
+    name: str = "new-session"
+    project_path: str = "."
+    current_agent: str = "claude"
+    current_model: str = "claude-sonnet-4"
+    system_prompt: str = (
+        "You are an expert AI software engineer. You have tools to inspect files, "
+        "write code, run commands, and build software. Be concise, precise, and proactive."
+    )
+    created_at: float = field(default_factory=time.time)
+    updated_at: float = field(default_factory=time.time)
+    messages: list[Message] = field(default_factory=list)
+
+    def add_user_message(self, content: str) -> Message:
+        msg = Message(role="user", content=content)
+        self.messages.append(msg)
+        self.updated_at = time.time()
+        return msg
+
+    def add_assistant_message(
+        self,
+        content: str,
+        agent_name: str,
+        model: str,
+        company: str = "",
+        tokens: int = 0,
+    ) -> Message:
+        msg = Message(
+            role="assistant",
+            content=content,
+            agent_name=agent_name,
+            model=model,
+            company=company,
+            tokens=tokens,
+        )
+        self.messages.append(msg)
+        self.updated_at = time.time()
+        return msg
+
+    def to_portable_messages(self) -> list[dict[str, Any]]:
+        """
+        Convert messages to clean LLM-compatible format:
+        [{"role": "user"|"assistant", "content": "..."}]
+        """
+        portable = []
+        for m in self.messages:
+            if m.role in ("user", "assistant"):
+                portable.append({"role": m.role, "content": m.content})
+        return portable
+
+    def switch_agent(self, agent_name: str, model: str) -> None:
+        """Switch current agent and model while preserving full history."""
+        self.current_agent = agent_name
+        self.current_model = model
+        self.updated_at = time.time()
+
+    def get_total_tokens(self) -> int:
+        return sum(m.tokens for m in self.messages)
+
+    def save(self, custom_name: str | None = None) -> Path:
+        """Save session to ~/.thwip/sessions/<id>.json."""
+        if custom_name:
+            self.name = custom_name
+        sessions_dir = get_sessions_dir()
+        file_path = sessions_dir / f"{self.name}.json"
+        data = {
+            "id": self.id,
+            "name": self.name,
+            "project_path": self.project_path,
+            "current_agent": self.current_agent,
+            "current_model": self.current_model,
+            "system_prompt": self.system_prompt,
+            "created_at": self.created_at,
+            "updated_at": self.updated_at,
+            "messages": [m.to_dict() for m in self.messages],
+        }
+        file_path.write_text(json.dumps(data, indent=2))
+        return file_path
+
+    @classmethod
+    def load(cls, name_or_id: str) -> "Session | None":
+        """Load session by name or id."""
+        sessions_dir = get_sessions_dir()
+        path = sessions_dir / f"{name_or_id}.json"
+        if not path.is_file():
+            # Try searching all sessions
+            for f in sessions_dir.glob("*.json"):
+                try:
+                    d = json.loads(f.read_text())
+                    if d.get("id") == name_or_id or d.get("name") == name_or_id:
+                        path = f
+                        break
+                except Exception:
+                    continue
+        if not path.is_file():
+            return None
+
+        try:
+            data = json.loads(path.read_text())
+            session = cls(
+                id=data.get("id", ""),
+                name=data.get("name", "saved-session"),
+                project_path=data.get("project_path", "."),
+                current_agent=data.get("current_agent", "claude"),
+                current_model=data.get("current_model", "claude-sonnet-4"),
+                system_prompt=data.get("system_prompt", ""),
+                created_at=data.get("created_at", time.time()),
+                updated_at=data.get("updated_at", time.time()),
+                messages=[Message.from_dict(m) for m in data.get("messages", [])],
+            )
+            return session
+        except Exception:
+            return None
+
+    @classmethod
+    def list_saved_sessions(cls) -> list[dict[str, Any]]:
+        """List all saved sessions with summary stats."""
+        sessions_dir = get_sessions_dir()
+        result = []
+        for f in sessions_dir.glob("*.json"):
+            try:
+                data = json.loads(f.read_text())
+                result.append({
+                    "id": data.get("id"),
+                    "name": data.get("name", f.stem),
+                    "agent": data.get("current_agent"),
+                    "model": data.get("current_model"),
+                    "messages_count": len(data.get("messages", [])),
+                    "updated_at": datetime.fromtimestamp(data.get("updated_at", 0)).strftime("%Y-%m-%d %H:%M"),
+                })
+            except Exception:
+                continue
+        return sorted(result, key=lambda x: x["updated_at"], reverse=True)

thwip/shortcuts.py

@@ -0,0 +1,75 @@
+"""
+Keyboard shortcut bindings & autocompletion for thwip terminal interface.
+"""
+
+from __future__ import annotations
+
+from prompt_toolkit.completion import Completer, Completion
+from prompt_toolkit.key_binding import KeyBindings
+
+
+SLASH_COMMANDS = [
+    ("/switch", "Switch agent and model mid-conversation"),
+    ("/agents", "Show all detected coding agents & status"),
+    ("/models", "List available models for current agent"),
+    ("/status", "Display current session and agent info"),
+    ("/limits", "View token usage, quota, and spend metrics"),
+    ("/detect", "Re-scan system for newly installed coding agents"),
+    ("/session save", "Save current chat session"),
+    ("/session load", "Resume a previously saved session"),
+    ("/session list", "List all saved sessions"),
+    ("/session clear", "Clear current conversation context"),
+    ("/history", "Show conversation with model attribution badges"),
+    ("/project", "View or change project working directory"),
+    ("/cost", "Show estimated cost breakdown"),
+    ("/help", "Show all available commands and keyboard shortcuts"),
+    ("/quit", "Exit thwip"),
+]
+
+
+class ThwipCompleter(Completer):
+    """Provides smart auto-completion for slash commands and agent names."""
+
+    def __init__(self, agent_names: list[str] | None = None) -> None:
+        self.agent_names = agent_names or ["claude", "google", "openai", "deepseek", "groq", "ollama", "openrouter"]
+
+    def get_completions(self, document, complete_event):
+        text = document.text_before_cursor
+        if text.startswith("/"):
+            # Command autocompletion
+            for cmd, desc in SLASH_COMMANDS:
+                if cmd.startswith(text):
+                    yield Completion(cmd, start_position=-len(text), display_meta=desc)
+
+            # /switch <agent> autocompletion
+            if text.startswith("/switch "):
+                parts = text.split(" ")
+                prefix = parts[1] if len(parts) > 1 else ""
+                for name in self.agent_names:
+                    if name.startswith(prefix):
+                        yield Completion(f"/switch {name}", start_position=-len(text), display_meta="Agent")
+
+
+def create_keybindings(on_switch=None, on_status=None, on_history=None) -> KeyBindings:
+    """Create keybindings for prompt_toolkit."""
+    kb = KeyBindings()
+
+    @kb.add("c-s")
+    def _switch(event):
+        """Ctrl+S: Quick switch prompt."""
+        event.app.current_buffer.text = "/switch "
+        event.app.current_buffer.cursor_position = len(event.app.current_buffer.text)
+
+    @kb.add("c-t")
+    def _status(event):
+        """Ctrl+T: Status view."""
+        event.app.current_buffer.text = "/status"
+        event.app.current_buffer.validate_and_handle()
+
+    @kb.add("c-h")
+    def _history(event):
+        """Ctrl+H: Show history."""
+        event.app.current_buffer.text = "/history"
+        event.app.current_buffer.validate_and_handle()
+
+    return kb

thwip/theme.py

@@ -0,0 +1,380 @@
+"""
+Theme and terminal styling for thwip.
+
+Each agent/company gets its own brand color, and the UI dynamically
+adapts based on which agent is active and what capabilities it has.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+from rich.text import Text
+from rich.theme import Theme
+from rich.markdown import Markdown
+from rich.syntax import Syntax
+from rich import box
+
+if TYPE_CHECKING:
+    from thwip.agents.base import BaseAgent, Capability
+
+
+# ---------------------------------------------------------------------------
+# Company / Provider Brand Colors
+# ---------------------------------------------------------------------------
+
+@dataclass(frozen=True)
+class BrandTheme:
+    """Visual identity for an agent's company."""
+    primary: str        # Main brand color
+    secondary: str      # Accent color
+    label_style: str    # Rich style string for labels
+
+
+BRAND_THEMES: dict[str, BrandTheme] = {
+    "anthropic": BrandTheme(
+        primary="#D97757",
+        secondary="#F5E6D3",
+        label_style="bold #D97757",
+    ),
+    "google": BrandTheme(
+        primary="#4285F4",
+        secondary="#E8F0FE",
+        label_style="bold #4285F4",
+    ),
+    "openai": BrandTheme(
+        primary="#10A37F",
+        secondary="#D1FAE5",
+        label_style="bold #10A37F",
+    ),
+    "deepseek": BrandTheme(
+        primary="#4D6BFE",
+        secondary="#E0E7FF",
+        label_style="bold #4D6BFE",
+    ),
+    "mistral": BrandTheme(
+        primary="#FF7000",
+        secondary="#FFF3E0",
+        label_style="bold #FF7000",
+    ),
+    "groq": BrandTheme(
+        primary="#F55036",
+        secondary="#FEE2E2",
+        label_style="bold #F55036",
+    ),
+    "ollama": BrandTheme(
+        primary="#E5E7EB",
+        secondary="#374151",
+        label_style="bold #E5E7EB",
+    ),
+    "openrouter": BrandTheme(
+        primary="#8B5CF6",
+        secondary="#EDE9FE",
+        label_style="bold #8B5CF6",
+    ),
+    "default": BrandTheme(
+        primary="#A78BFA",
+        secondary="#1E1B2E",
+        label_style="bold #A78BFA",
+    ),
+}
+
+
+def get_brand(company: str) -> BrandTheme:
+    """Get brand theme for a company, falling back to default."""
+    return BRAND_THEMES.get(company.lower(), BRAND_THEMES["default"])
+
+
+# ---------------------------------------------------------------------------
+# Rich Console Setup
+# ---------------------------------------------------------------------------
+
+THWIP_THEME = Theme({
+    "info": "dim cyan",
+    "warning": "bold yellow",
+    "error": "bold red",
+    "success": "bold green",
+    "muted": "dim",
+    "user.label": "bold cyan",
+    "agent.label": "bold magenta",
+    "capability.yes": "bold green",
+    "capability.no": "dim red",
+    "capability.warn": "bold yellow",
+    "status.ready": "bold green",
+    "status.no_key": "bold red",
+    "status.limited": "bold yellow",
+    "status.local": "bold cyan",
+    "status.ide": "dim yellow",
+    "badge": "bold dim",
+    "prompt": "bold white",
+    "header": "bold white on #1E1B2E",
+})
+
+console = Console(theme=THWIP_THEME)
+
+
+# ---------------------------------------------------------------------------
+# UI Rendering Helpers
+# ---------------------------------------------------------------------------
+
+def render_startup_banner(
+    agent_name: str,
+    company: str,
+    model: str,
+    project_path: str,
+    session_name: str,
+    agents_detected: int,
+    agents_ready: int,
+) -> Panel:
+    """Render the startup banner with current agent info."""
+    brand = get_brand(company)
+
+    lines = Text()
+    lines.append("thwip", style="bold white")
+    lines.append(" v1.0\n", style="dim")
+    lines.append("Universal Coding Agent Multiplexer\n\n", style="dim italic")
+    lines.append("  Agent:    ", style="dim")
+    lines.append(f"{agent_name}", style=brand.label_style)
+    lines.append(f" ({company})\n", style="dim")
+    lines.append("  Model:    ", style="dim")
+    lines.append(f"{model}\n", style="bold white")
+    lines.append("  Project:  ", style="dim")
+    lines.append(f"{project_path}\n", style="white")
+    lines.append("  Session:  ", style="dim")
+    lines.append(f"{session_name}\n", style="white")
+    lines.append("  Agents:   ", style="dim")
+    lines.append(f"{agents_detected}", style="bold white")
+    lines.append(" detected, ", style="dim")
+    lines.append(f"{agents_ready}", style="success")
+    lines.append(" ready", style="dim")
+
+    return Panel(
+        lines,
+        border_style=brand.primary,
+        box=box.ROUNDED,
+        padding=(1, 2),
+    )
+
+
+def render_agent_badge(agent_name: str, model: str, company: str) -> Text:
+    """Render an inline badge for message attribution."""
+    brand = get_brand(company)
+    badge = Text()
+    badge.append("[", style="dim")
+    badge.append(f"{model}", style=brand.label_style)
+    badge.append("]", style="dim")
+    return badge
+
+
+def render_agents_table(agents: list[dict]) -> Table:
+    """
+    Render the detected agents table.
+
+    Each agent dict should have:
+    name, company, status, status_style, models, capabilities, subscription
+    """
+    table = Table(
+        title="Detected Agents",
+        box=box.ROUNDED,
+        border_style="dim",
+        title_style="bold white",
+        show_lines=True,
+        padding=(0, 1),
+    )
+
+    table.add_column("Agent", style="bold white", min_width=14)
+    table.add_column("Company", style="dim", min_width=12)
+    table.add_column("Status", min_width=10)
+    table.add_column("Models", style="white", min_width=16)
+    table.add_column("Capabilities", min_width=24)
+    table.add_column("Subscription", min_width=12)
+
+    for agent in agents:
+        status_text = Text(agent.get("status", "Unknown"))
+        status_text.stylize(agent.get("status_style", "dim"))
+
+        cap_text = Text()
+        caps = agent.get("capabilities", [])
+        for i, cap in enumerate(caps):
+            if i > 0:
+                cap_text.append(", ", style="dim")
+            cap_text.append(cap, style="capability.yes")
+
+        missing = agent.get("missing_capabilities", [])
+        for i, cap in enumerate(missing):
+            if caps or i > 0:
+                cap_text.append(", ", style="dim")
+            cap_text.append(f"-{cap}-", style="capability.no")
+
+        sub = agent.get("subscription", "Unknown")
+        sub_style = "success" if sub in ("Active", "Free", "Unlimited") else "warning" if sub == "Unknown" else "error"
+        sub_text = Text(sub, style=sub_style)
+
+        table.add_row(
+            agent["name"],
+            agent.get("company", "-"),
+            status_text,
+            agent.get("models", "-"),
+            cap_text,
+            sub_text,
+        )
+
+    return table
+
+
+def render_capability_disclaimer(
+    agent_name: str,
+    company: str,
+    supported: list[str],
+    unsupported: list[str],
+) -> Panel:
+    """Render a capability disclaimer when switching agents."""
+    brand = get_brand(company)
+    content = Text()
+
+    content.append("Switched to ", style="dim")
+    content.append(f"{agent_name}", style=brand.label_style)
+    content.append(f" ({company})\n\n", style="dim")
+
+    if supported:
+        content.append("  Supported: ", style="success")
+        content.append(", ".join(supported), style="white")
+        content.append("\n")
+
+    if unsupported:
+        content.append("  Not available: ", style="error")
+        content.append(", ".join(unsupported), style="dim red")
+        content.append("\n\n")
+        content.append(
+            "  Notice: This agent may not support editing files, running code,\n"
+            "  or other actions that your previous agent could do.\n"
+            "  Chat capabilities will continue.",
+            style="warning",
+        )
+
+    border_style = "yellow" if unsupported else brand.primary
+    return Panel(
+        content,
+        title="Agent Switch",
+        title_align="left",
+        border_style=border_style,
+        box=box.ROUNDED,
+        padding=(0, 2),
+    )
+
+
+def render_limit_warning(
+    agent_name: str,
+    company: str,
+    error_type: str,
+    alternatives: list[dict],
+) -> Panel:
+    """Render the limit exhaustion warning with alternative suggestions."""
+    brand = get_brand(company)
+    content = Text()
+
+    content.append(f"Notice: {agent_name}", style=brand.label_style)
+    if error_type == "quota_exhausted":
+        content.append(" - quota exhausted for this billing period.\n\n", style="warning")
+    elif error_type == "rate_limited":
+        content.append(" - rate limited. Retry in a moment, or switch.\n\n", style="warning")
+    else:
+        content.append(f" - {error_type}\n\n", style="warning")
+
+    if alternatives:
+        content.append("Ready alternatives:\n", style="dim")
+        for i, alt in enumerate(alternatives, 1):
+            alt_brand = get_brand(alt.get("company", ""))
+            content.append(f"  {i}. ", style="bold white")
+            content.append(f"{alt['agent']}", style=alt_brand.label_style)
+            content.append(f" -> {alt['model']}", style="white")
+            caps = alt.get("capabilities", [])
+            if caps:
+                content.append(f"  ({', '.join(caps)})", style="dim green")
+            content.append("\n")
+
+    return Panel(
+        content,
+        border_style="yellow",
+        box=box.ROUNDED,
+        padding=(0, 2),
+    )
+
+
+def render_dynamic_status_bar(
+    agent_name: str,
+    company: str,
+    model: str,
+    capabilities: list[str],
+    tokens_used: int = 0,
+    cost: float = 0.0,
+) -> Text:
+    """Render the bottom status bar based on active agent capabilities."""
+    brand = get_brand(company)
+    bar = Text()
+
+    bar.append(f" {agent_name}", style=brand.label_style)
+    bar.append(" | ", style="dim")
+    bar.append(f"{model}", style="bold white")
+    bar.append(" | ", style="dim")
+
+    cap_labels = [
+        ("chat", "chat"),
+        ("file_edit", "edit"),
+        ("code_run", "run"),
+        ("terminal", "term"),
+        ("git", "git"),
+        ("browser", "web"),
+    ]
+    for cap_key, label in cap_labels:
+        if cap_key in capabilities:
+            bar.append(f"[{label}] ", style="success")
+        else:
+            bar.append(f"[{label}] ", style="dim #444444")
+
+    if tokens_used > 0:
+        bar.append("| ", style="dim")
+        bar.append(f"{tokens_used:,} tok", style="dim cyan")
+    if cost > 0:
+        bar.append(" | ", style="dim")
+        bar.append(f"${cost:.4f}", style="dim green")
+
+    return bar
+
+
+def render_user_prompt() -> Text:
+    """Render the user input prompt."""
+    prompt = Text()
+    prompt.append("\n You", style="bold cyan")
+    prompt.append(" > ", style="dim cyan")
+    return prompt
+
+
+def render_markdown_response(content: str) -> Markdown:
+    """Render agent response as markdown."""
+    return Markdown(content, code_theme="monokai")
+
+
+def render_code_block(code: str, language: str = "python") -> Syntax:
+    """Render a syntax-highlighted code block."""
+    return Syntax(code, language, theme="monokai", line_numbers=True)
+
+
+def print_info(message: str) -> None:
+    console.print(f"  [info][info] {message}[/info]")
+
+
+def print_success(message: str) -> None:
+    console.print(f"  [success][ok] {message}[/success]")
+
+
+def print_warning(message: str) -> None:
+    console.print(f"  [warning][warn] {message}[/warning]")
+
+
+def print_error(message: str) -> None:
+    console.print(f"  [error][error] {message}[/error]")