cade-cli 0.3.3__py3-none-any.whl

cadecoder/ui/session.py

@@ -0,0 +1,455 @@
+"""Main chat session for the TUI."""
+
+import asyncio
+import json
+import os
+import signal
+import sys
+from typing import Any
+
+from rich.live import Live
+from rich.markdown import Markdown
+from ulid import ulid
+
+from cadecoder.core.constants import DEFAULT_AI_MODEL
+from cadecoder.core.errors import AuthError
+from cadecoder.core.logging import log
+from cadecoder.core.types import ExecutionEventType
+from cadecoder.execution.orchestrator import (
+    ExecutionContext,
+    create_orchestrator,
+)
+from cadecoder.storage.threads import (
+    Message,
+    ModelInfo,
+    ToolCallInfo,
+    get_thread_history,
+)
+from cadecoder.tools.git import get_current_branch_name
+from cadecoder.ui.display import (
+    clear_screen,
+    console,
+    display_git_branch_info,
+    display_help,
+    display_logs,
+    display_messages,
+    display_thread_header,
+    display_tool_result,
+    display_tools_async,
+    strip_control_signals,
+)
+
+# Box-drawing characters that break Rich Markdown rendering
+_BOX_CHARS = frozenset("┌┐└┘├┤┬┴┼─│═║╔╗╚╝╠╣╦╩╬")
+
+
+def _has_box_chars(text: str) -> bool:
+    """Check if text contains box-drawing characters."""
+    return bool(_BOX_CHARS & set(text))
+
+
+class ChatSession:
+    """Manages a chat session with the AI agent."""
+
+    def __init__(
+        self,
+        thread_id: str,
+        model: str = DEFAULT_AI_MODEL,
+        system_prompt: str | None = None,
+    ) -> None:
+        """Initialize chat session."""
+        self.thread_id = thread_id
+        self.model = model
+        self.system_prompt = system_prompt
+        self.history_manager = get_thread_history()
+        self.thread = self.history_manager.get_thread(thread_id)
+        self.orchestrator = create_orchestrator(default_model=model)
+        self.current_task: asyncio.Task | None = None
+        self._ctrl_c_count = 0
+
+    def get_conversation_history(self) -> list[dict[str, Any]]:
+        """Get conversation history in LLM format."""
+        messages = self.history_manager.get_messages(self.thread_id)
+        history: list[dict[str, Any]] = []
+
+        for msg in messages:
+            if msg.role == "system":
+                history.append({"role": "system", "content": msg.content or ""})
+            elif msg.role == "user":
+                history.append({"role": "user", "content": msg.content or ""})
+            elif msg.role == "assistant":
+                entry: dict[str, Any] = {"role": "assistant", "content": msg.content}
+                if msg.tool_calls:
+                    entry["tool_calls"] = [
+                        {
+                            "id": tc.call_id,
+                            "type": "function",
+                            "function": {
+                                "name": tc.tool_name,
+                                "arguments": json.dumps(tc.parameters),
+                            },
+                        }
+                        for tc in msg.tool_calls
+                    ]
+                history.append(entry)
+            elif msg.role == "tool":
+                history.append(
+                    {
+                        "role": "tool",
+                        "tool_call_id": msg.responding_tool_call_id or "",
+                        "content": msg.content or "",
+                    }
+                )
+
+        return history
+
+    def save_user_message(self, content: str) -> Message:
+        """Save a user message."""
+        message = Message(
+            id=str(ulid()).lower(),
+            thread_id=self.thread_id,
+            role="user",
+            content=content,
+        )
+        self.history_manager.add_message(message)
+        return message
+
+    def save_assistant_message(
+        self,
+        content: str | None,
+        tool_calls: list[dict[str, Any]] | None = None,
+        model_info: ModelInfo | None = None,
+    ) -> Message:
+        """Save an assistant message."""
+        tc_infos = []
+        if tool_calls:
+            for tc in tool_calls:
+                func = tc.get("function", {})
+                args_raw = func.get("arguments", "{}")
+                if isinstance(args_raw, str):
+                    try:
+                        params = json.loads(args_raw)
+                    except json.JSONDecodeError:
+                        params = {"raw": args_raw}
+                else:
+                    params = args_raw if isinstance(args_raw, dict) else {}
+
+                tc_infos.append(
+                    ToolCallInfo(
+                        call_id=tc.get("id", str(ulid()).lower()),
+                        tool_name=func.get("name", "unknown"),
+                        parameters=params,
+                    )
+                )
+
+        message = Message(
+            id=str(ulid()).lower(),
+            thread_id=self.thread_id,
+            role="assistant",
+            content=content,
+            tool_calls=tc_infos,
+            model_info=model_info,
+        )
+        self.history_manager.add_message(message)
+        return message
+
+    def save_tool_message(self, tool_call_id: str, content: str, tool_name: str) -> Message:
+        """Save a tool response message."""
+        message = Message(
+            id=str(ulid()).lower(),
+            thread_id=self.thread_id,
+            role="tool",
+            content=content,
+            responding_tool_call_id=tool_call_id,
+        )
+        self.history_manager.add_message(message)
+        return message
+
+    async def process_input(self, user_input: str) -> None:
+        """Process user input."""
+        if user_input.startswith("/"):
+            await self.handle_command(user_input)
+            return
+
+        history = self.get_conversation_history()
+        self.save_user_message(user_input)
+
+        context = ExecutionContext(task=user_input, conversation_history=history)
+        accumulated_content = ""
+        tool_calls: list[dict[str, Any]] = []
+        tool_results: list[tuple[str, str, str]] = []
+
+        console.print()
+
+        try:
+            with Live(console=console, refresh_per_second=10) as live:
+                async for event in self.orchestrator.stream(context):
+                    if event.type == ExecutionEventType.CONTENT:
+                        accumulated_content += event.content or ""
+                        display_content = strip_control_signals(
+                            accumulated_content, strip_whitespace=True
+                        )
+                        if display_content:
+                            # Plain text for box chars (Markdown breaks them)
+                            if _has_box_chars(display_content):
+                                live.update(display_content)
+                            else:
+                                live.update(Markdown(display_content))
+
+                    elif event.type == ExecutionEventType.TOOL_CALL:
+                        tc = event.metadata.get("tool_call", {})
+                        tool_calls.append(tc)
+                        func = tc.get("function", {})
+                        tool_name = func.get("name", "unknown")
+                        console.print(f"[dim]Calling tool: {tool_name}[/dim]")
+
+                    elif event.type == ExecutionEventType.TOOL_RESULT:
+                        tool_name = event.metadata.get("tool_name", "unknown")
+                        tool_call_id = event.metadata.get("tool_call_id", "")
+                        result_content = event.content or ""
+                        display_tool_result(tool_name, result_content)
+                        tool_results.append((tool_call_id, tool_name, result_content))
+
+        except asyncio.CancelledError:
+            console.print("\n[yellow]Operation cancelled.[/yellow]")
+            return
+        except Exception as e:
+            console.print(f"\n[red]Error: {e}[/red]")
+            log.error(f"Error processing input: {e}", exc_info=True)
+            return
+
+        # Save assistant message
+        if accumulated_content or tool_calls:
+            self.save_assistant_message(accumulated_content, tool_calls)
+
+        # Save tool results
+        for tool_call_id, tool_name, result_content in tool_results:
+            self.save_tool_message(tool_call_id, result_content, tool_name)
+
+        console.print()
+
+    async def handle_command(self, cmd: str) -> None:
+        """Handle slash commands."""
+        cmd = cmd.strip()
+
+        if cmd in ("/exit", "/quit"):
+            raise SystemExit(0)
+        elif cmd == "/help":
+            display_help()
+        elif cmd == "/clear":
+            clear_screen()
+        elif cmd == "/history":
+            messages = self.history_manager.get_messages(self.thread_id)
+            display_messages(messages)
+        elif cmd == "/model":
+            console.print(f"[cyan]Current model: {self.model}[/cyan]")
+        elif cmd == "/thread":
+            if self.thread:
+                console.print(f"[cyan]Thread ID: {self.thread.thread_id}[/cyan]")
+                console.print(f"[cyan]Name: {self.thread.name or 'Unnamed'}[/cyan]")
+            else:
+                console.print(f"[cyan]Thread ID: {self.thread_id}[/cyan]")
+        elif cmd == "/logs":
+            display_logs()
+        elif cmd == "/tools":
+            await display_tools_async(self.orchestrator.tool_manager)
+        elif cmd == "/context":
+            history = self.get_conversation_history()
+            status = self.orchestrator.get_context_status(history)
+            console.print("[cyan]Context Window Status:[/cyan]")
+            console.print(f"  Tokens: {status['token_count']:,} / {status['effective_limit']:,}")
+            console.print(f"  Used: {status['percentage_used']}%")
+            console.print(f"  Messages: {status['message_count']}")
+            console.print(f"  Needs compaction: {status['needs_compaction']}")
+
+            tool_summary = self.orchestrator.get_tool_outputs_summary()
+            if tool_summary["total_outputs"] > 0:
+                console.print("\n[cyan]Tool Outputs:[/cyan]")
+                console.print(f"  Total outputs: {tool_summary['total_outputs']}")
+                console.print(f"  Unique tools: {tool_summary['unique_tools']}")
+                console.print(f"  Estimated tokens: {tool_summary['estimated_tokens']:,}")
+        elif cmd == "/pwd":
+            console.print(f"[cyan]{os.getcwd()}[/cyan]")
+        elif cmd.startswith("/cd "):
+            path = cmd[4:].strip()
+            try:
+                os.chdir(path)
+                console.print(f"[green]Changed to: {os.getcwd()}[/green]")
+            except Exception as e:
+                console.print(f"[red]Error: {e}[/red]")
+        elif cmd.startswith("/! "):
+            import subprocess
+
+            shell_cmd = cmd[3:].strip()
+            try:
+                result = subprocess.run(shell_cmd, shell=True, capture_output=True, text=True)
+                if result.stdout:
+                    console.print(result.stdout)
+                if result.stderr:
+                    console.print(f"[red]{result.stderr}[/red]")
+            except Exception as e:
+                console.print(f"[red]Error: {e}[/red]")
+        else:
+            console.print(f"[yellow]Unknown command: {cmd}[/yellow]")
+            console.print("[dim]Type /help for available commands[/dim]")
+
+    def cancel_current_task(self) -> None:
+        """Cancel the current running task."""
+        if self.current_task and not self.current_task.done():
+            self.current_task.cancel()
+
+
+async def run_session(session: ChatSession) -> None:
+    """Run the chat session loop."""
+    loop = asyncio.get_running_loop()
+    stop_requested = False
+
+    def handle_sigint() -> None:
+        """Handle Ctrl+C - exit immediately."""
+        nonlocal stop_requested
+        if stop_requested or session._ctrl_c_count >= 1:
+            console.print("\n[bold red]Exiting.[/bold red]")
+            os._exit(0)
+        session._ctrl_c_count += 1
+        stop_requested = True
+        session.cancel_current_task()
+        console.print("\n[yellow]Exiting... (Ctrl+C again to force)[/yellow]")
+
+    try:
+        loop.add_signal_handler(signal.SIGINT, handle_sigint)
+    except (NotImplementedError, ValueError):
+        pass
+
+    # Display header
+    branch_name, _ = get_current_branch_name()
+    display_git_branch_info(branch_name)
+
+    thread_name = session.thread.name if session.thread else session.thread_id[:8]
+    display_thread_header(thread_name)
+
+    # Display existing messages
+    messages = session.history_manager.get_messages(session.thread_id)
+    if messages:
+        display_messages(messages)
+
+    # Main loop
+    while not stop_requested:
+        try:
+            session._ctrl_c_count = 0
+            user_input = await loop.run_in_executor(None, lambda: input("> "))
+
+            if stop_requested:
+                break
+
+            if not user_input.strip():
+                continue
+
+            session.current_task = asyncio.create_task(session.process_input(user_input.strip()))
+
+            try:
+                await session.current_task
+            except asyncio.CancelledError:
+                console.print("[yellow]Cancelled.[/yellow]")
+                if stop_requested:
+                    break
+
+        except EOFError:
+            console.print("\n[dim]Exiting.[/dim]")
+            break
+        except KeyboardInterrupt:
+            console.print("\n[dim]Exiting.[/dim]")
+            break
+        except SystemExit:
+            break
+
+    console.print("[dim]Session ended.[/dim]")
+
+
+def main(
+    thread_id_to_run: str,
+    model: str = DEFAULT_AI_MODEL,
+    stream: bool = False,
+    system_prompt: str | None = None,
+    target_symbol: str | None = None,
+) -> None:
+    """Main entry point for the TUI."""
+    try:
+        session = ChatSession(thread_id=thread_id_to_run, model=model, system_prompt=system_prompt)
+        asyncio.run(run_session(session))
+    except AuthError as e:
+        console.print(f"[red]Authentication error: {e}[/red]")
+        sys.exit(1)
+    except Exception as e:
+        log.error(f"Fatal error: {e}", exc_info=True)
+        console.print(f"[red]Fatal error: {e}[/red]")
+        sys.exit(1)
+
+
+async def _run_single_message(message: str, model: str = DEFAULT_AI_MODEL) -> int:
+    """Run a single message through the orchestrator.
+
+    Args:
+        message: The user message to process
+        model: Model to use
+
+    Returns:
+        Exit code (0=success, 1=error, 2=needs interactive)
+    """
+    orchestrator = create_orchestrator(default_model=model)
+    context = ExecutionContext(task=message, conversation_history=[])
+
+    accumulated_content = ""
+
+    try:
+        # Status to stderr
+        print("\033[2m\033[3m[Processing...]\033[0m", file=sys.stderr)
+
+        async for event in orchestrator.stream(context):
+            if event.type == ExecutionEventType.CONTENT:
+                chunk = event.content or ""
+                cleaned = strip_control_signals(chunk, strip_whitespace=False)
+                accumulated_content += cleaned
+
+            elif event.type == ExecutionEventType.TOOL_CALL:
+                tc = event.metadata.get("tool_call", {})
+                func = tc.get("function", {})
+                tool_name = func.get("name", "unknown")
+                print(f"\033[2m\033[3m[Calling: {tool_name}]\033[0m", file=sys.stderr)
+
+            elif event.type == ExecutionEventType.TOOL_RESULT:
+                tool_name = event.metadata.get("tool_name", "unknown")
+                result = event.content or ""
+                preview = result[:80] + "..." if len(result) > 80 else result
+                preview = preview.replace("\n", " ")
+                print(
+                    f"\033[2m\033[3m[Result: {tool_name}] {preview}\033[0m",
+                    file=sys.stderr,
+                )
+
+        # Final output to stdout
+        final_output = strip_control_signals(accumulated_content, strip_whitespace=True)
+        if final_output:
+            print(final_output)
+
+        return 0
+
+    except AuthError:
+        print("\033[2m\033[3m[Authentication required]\033[0m", file=sys.stderr)
+        return 2
+    except Exception as e:
+        print(f"Error: {e}", file=sys.stderr)
+        log.error(f"Single message error: {e}", exc_info=True)
+        return 1
+
+
+def run_single_message_mode(message: str, model: str = DEFAULT_AI_MODEL) -> int:
+    """Entry point for single message mode.
+
+    Args:
+        message: The user message to process
+        model: Model to use
+
+    Returns:
+        Exit code (0=success, 1=error, 2=needs interactive)
+    """
+    return asyncio.run(_run_single_message(message, model))

cadecoder/ui/state.py

@@ -0,0 +1,20 @@
+"""State management for the TUI application."""
+
+from dataclasses import dataclass, field
+from typing import Any
+
+
+@dataclass
+class TuiState:
+    """Main TUI application state."""
+
+    chat_mode: str = "agent"
+    show_tools: bool = False
+    orchestrator: Any = None
+    message_history_index: int = -1
+    cached_user_messages: list[str] = field(default_factory=list)
+    expand_tool_results: bool = True
+
+
+# Global application state
+app_state = TuiState()