tsugite-cli 0.3.3__py3-none-any.whl

tsugite/ui/chat.py

@@ -0,0 +1,265 @@
+"""Chat session management for interactive conversations with agents."""
+
+import json
+from datetime import datetime
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from tsugite.config import load_config
+from tsugite.md_agents import parse_agent_file
+from tsugite.ui import CustomUILogger
+
+
+class ChatTurn(BaseModel):
+    """Represents one turn in a conversation."""
+
+    model_config = ConfigDict(
+        extra="forbid",
+    )
+
+    timestamp: datetime
+    user_message: str
+    agent_response: str
+    tool_calls: List[str] = Field(default_factory=list)
+    token_count: Optional[int] = None
+    cost: Optional[float] = None
+
+
+class ChatManager:
+    """Manages chat sessions with conversation history."""
+
+    def __init__(
+        self,
+        agent_path: Path,
+        model_override: Optional[str] = None,
+        max_history: int = 50,
+        custom_logger: Optional[CustomUILogger] = None,
+        stream: bool = False,
+        disable_history: bool = False,
+        resume_conversation_id: Optional[str] = None,
+    ):
+        """Initialize chat manager.
+
+        Args:
+            agent_path: Path to agent markdown file
+            model_override: Override agent's default model
+            max_history: Maximum turns to keep in context
+            custom_logger: Optional custom logger for UI
+            stream: Whether to stream responses in real-time
+            disable_history: Disable conversation history persistence
+            resume_conversation_id: Optional conversation ID to resume (skips auto-generation)
+        """
+        self.agent_path = agent_path
+        self.model_override = model_override
+        self.max_history = max_history
+        self.custom_logger = custom_logger
+        self.stream = stream
+        self.conversation_history: List[ChatTurn] = []
+        self.session_start = datetime.now()
+
+        # History support
+        self.conversation_id: Optional[str] = resume_conversation_id
+        config = load_config()
+        history_enabled = getattr(config, "history_enabled", True) and not disable_history
+
+        # Only create new conversation if not resuming
+        if history_enabled and not resume_conversation_id:
+            try:
+                from tsugite.ui.chat_history import start_conversation
+
+                agent = parse_agent_file(agent_path)
+                model = model_override or agent.config.model or "unknown"
+
+                self.conversation_id = start_conversation(
+                    agent_name=agent.config.name or agent_path.stem,
+                    model=model,
+                    timestamp=self.session_start,
+                )
+            except Exception as e:
+                # Don't fail if history can't be initialized
+                print(f"Warning: Failed to initialize conversation history: {e}")
+                self.conversation_id = None
+
+    def load_from_history(self, conversation_id: str, turns: List[Any]) -> None:
+        """Load conversation history from JSONL storage.
+
+        Args:
+            conversation_id: Conversation ID to resume
+            turns: List of Turn objects from history
+
+        Raises:
+            RuntimeError: If loading fails
+        """
+        try:
+            from tsugite.history import Turn
+
+            self.conversation_id = conversation_id
+            self.conversation_history = []
+
+            # Convert Turn objects from history to ChatTurn objects
+            for turn in turns:
+                if not isinstance(turn, Turn):
+                    continue
+
+                chat_turn = ChatTurn(
+                    timestamp=turn.timestamp,
+                    user_message=turn.user,
+                    agent_response=turn.assistant,
+                    tool_calls=turn.tools or [],
+                    token_count=turn.tokens,
+                    cost=turn.cost,
+                )
+                self.conversation_history.append(chat_turn)
+
+            # Update session_start to first turn's timestamp if available
+            if self.conversation_history:
+                self.session_start = self.conversation_history[0].timestamp
+
+            # Prune if history exceeds max_history
+            if len(self.conversation_history) > self.max_history:
+                self.conversation_history = self.conversation_history[-self.max_history :]
+
+        except Exception as e:
+            raise RuntimeError(f"Failed to load conversation from history: {e}")
+
+    def add_turn(
+        self,
+        user_message: str,
+        agent_response: str,
+        tool_calls: List[str] = None,
+        token_count: Optional[int] = None,
+        cost: Optional[float] = None,
+        execution_steps: Optional[list] = None,
+        messages: Optional[list] = None,
+    ) -> None:
+        """Add a turn to conversation history."""
+        turn = ChatTurn(
+            timestamp=datetime.now(),
+            user_message=user_message,
+            agent_response=agent_response,
+            tool_calls=tool_calls or [],
+            token_count=token_count,
+            cost=cost,
+        )
+        self.conversation_history.append(turn)
+
+        # Save to persistent history if enabled
+        if self.conversation_id:
+            try:
+                from tsugite.ui.chat_history import save_chat_turn
+
+                save_chat_turn(
+                    conversation_id=self.conversation_id,
+                    user_message=user_message,
+                    agent_response=agent_response,
+                    tool_calls=tool_calls or [],
+                    token_count=token_count,
+                    cost=cost,
+                    timestamp=turn.timestamp,
+                    execution_steps=execution_steps,
+                    messages=messages,
+                )
+            except Exception as e:
+                # Don't fail the turn if history save fails
+                print(f"Warning: Failed to save turn to history: {e}")
+
+        # Prune old history if needed
+        if len(self.conversation_history) > self.max_history:
+            self.conversation_history = self.conversation_history[-self.max_history :]
+
+    def run_turn(self, user_input: str) -> str:
+        """Execute one chat turn with the agent.
+
+        Args:
+            user_input: User's message
+
+        Returns:
+            Agent's response
+        """
+        # Import here to avoid circular dependency
+        from tsugite.agent_runner import run_agent
+
+        try:
+            result = run_agent(
+                agent_path=self.agent_path,
+                prompt=user_input,
+                model_override=self.model_override,
+                custom_logger=self.custom_logger,
+                context={"chat_history": self.conversation_history},
+                return_token_usage=True,
+                stream=self.stream,
+                force_text_mode=True,  # Enable text mode for chat UI
+            )
+
+            # Handle tuple return (response, token_count, cost) or (response, token_count) or string return
+            response = None
+            token_count = None
+            cost = None
+
+            if isinstance(result, tuple):
+                if len(result) == 3:
+                    response, token_count, cost = result
+                elif len(result) == 2:
+                    response, token_count = result
+                else:
+                    response = result[0]
+            else:
+                response = result
+
+            self.add_turn(user_input, response, token_count=token_count, cost=cost)
+            return response
+
+        except Exception as e:
+            error_msg = f"Error: {str(e)}"
+            self.add_turn(user_input, error_msg)
+            return error_msg
+
+    def clear_history(self) -> None:
+        """Clear conversation history."""
+        self.conversation_history = []
+
+    def save_conversation(self, path: Path) -> None:
+        """Save conversation to JSON file."""
+        agent = parse_agent_file(self.agent_path)
+
+        data = {
+            "agent": agent.config.name or str(self.agent_path),
+            "model": self.model_override or agent.config.model,
+            "created_at": self.session_start.isoformat(),
+            "turns": [turn.model_dump(mode="json") for turn in self.conversation_history],
+            "metadata": {
+                "total_turns": len(self.conversation_history),
+                "agent_path": str(self.agent_path),
+            },
+        }
+
+        path.write_text(json.dumps(data, indent=2))
+
+    def load_conversation(self, path: Path) -> None:
+        """Load conversation from JSON file."""
+        data = json.loads(path.read_text())
+
+        self.conversation_history = []
+
+        for turn_data in data.get("turns", []):
+            turn = ChatTurn.model_validate(turn_data)
+            self.conversation_history.append(turn)
+
+        if "created_at" in data:
+            self.session_start = datetime.fromisoformat(data["created_at"])
+
+    def get_stats(self) -> Dict[str, Any]:
+        """Get session statistics."""
+        total_tokens = sum(turn.token_count for turn in self.conversation_history if turn.token_count)
+        total_cost = sum(turn.cost for turn in self.conversation_history if turn.cost)
+
+        return {
+            "total_turns": len(self.conversation_history),
+            "total_tokens": total_tokens if total_tokens > 0 else None,
+            "total_cost": total_cost if total_cost > 0 else None,
+            "session_duration": (datetime.now() - self.session_start).total_seconds(),
+            "agent": str(self.agent_path),
+            "model": self.model_override or "default",
+        }

tsugite/ui/chat.tcss

@@ -0,0 +1,92 @@
+/* Textual CSS for Chat UI */
+
+Screen {
+    background: $background;
+}
+
+Header {
+    dock: top;
+    height: 3;
+    background: $primary-background;
+}
+
+/* Top pane: Thought log showing execution summaries */
+ThoughtLog {
+    height: 35%;
+    border: solid $accent;
+    padding: 1;
+    background: $surface;
+}
+
+ThoughtLog:focus {
+    border: double $accent;
+}
+
+ThoughtLog > .scrollbar {
+    width: 1;
+}
+
+ThoughtLog > .scrollbar:focus {
+    width: 1;
+}
+
+ThoughtEntry {
+    width: 100%;
+    height: auto;
+    margin-bottom: 0;
+}
+
+/* Bottom pane: Clean chat conversation */
+MessageList {
+    height: 1fr;
+    border: solid $primary;
+    padding: 1;
+    background: $surface;
+}
+
+MessageList:focus {
+    border: double $primary;
+}
+
+MessageList > .scrollbar {
+    width: 1;
+}
+
+MessageList > .scrollbar:focus {
+    width: 1;
+}
+
+Message {
+    width: 100%;
+    height: auto;
+    margin-bottom: 1;
+}
+
+.separator {
+    color: $text-muted;
+    height: 1;
+    margin: 1 0;
+}
+
+.status {
+    color: $warning;
+    height: auto;
+    margin: 1 0;
+}
+
+Input {
+    border: solid $success;
+    background: $surface;
+    height: 3;
+}
+
+Input:focus {
+    border: double $success;
+}
+
+Footer {
+    dock: bottom;
+    height: 1;
+    background: $primary-background;
+    color: $text-muted;
+}

tsugite/ui/chat_history.py

@@ -0,0 +1,286 @@
+"""Chat history integration helpers."""
+
+import socket
+from datetime import datetime, timezone
+from typing import List, Optional, Union
+
+from tsugite.config import load_config
+from tsugite.history import (
+    ConversationMetadata,
+    IndexEntry,
+    Turn,
+    generate_conversation_id,
+    load_conversation,
+    query_index,
+    save_turn_to_history,
+    update_index,
+)
+
+
+def get_machine_name() -> str:
+    """Get machine name for conversation tracking.
+
+    Checks config for custom machine_name, falls back to hostname.
+
+    Returns:
+        Machine name string
+    """
+    config = load_config()
+
+    # Check config for override
+    if hasattr(config, "machine_name") and config.machine_name:
+        return config.machine_name
+
+    # Auto-detect from hostname
+    try:
+        return socket.gethostname()
+    except Exception:
+        return "unknown"
+
+
+def start_conversation(
+    agent_name: str,
+    model: str,
+    timestamp: Optional[datetime] = None,
+) -> str:
+    """Start a new conversation and save metadata.
+
+    Creates conversation ID and saves initial metadata line to JSONL file.
+
+    Args:
+        agent_name: Name of the agent
+        model: Model identifier (e.g., "openai:gpt-4o")
+        timestamp: Optional timestamp (defaults to now)
+
+    Returns:
+        Conversation ID
+
+    Raises:
+        RuntimeError: If save fails
+    """
+    if timestamp is None:
+        timestamp = datetime.now(timezone.utc)
+
+    conversation_id = generate_conversation_id(agent_name, timestamp)
+    machine = get_machine_name()
+
+    # Create ConversationMetadata model
+    metadata = ConversationMetadata(
+        id=conversation_id,
+        agent=agent_name,
+        model=model,
+        machine=machine,
+        created_at=timestamp,
+        timestamp=timestamp,
+    )
+
+    save_turn_to_history(conversation_id, metadata)
+
+    # Initialize index entry using IndexEntry model
+    index_metadata = IndexEntry(
+        agent=agent_name,
+        model=model,
+        machine=machine,
+        created_at=timestamp,
+        updated_at=timestamp,
+        turn_count=0,
+        total_tokens=0,
+        total_cost=0.0,
+    )
+    update_index(conversation_id, index_metadata)
+
+    return conversation_id
+
+
+def save_chat_turn(
+    conversation_id: str,
+    user_message: str,
+    agent_response: str,
+    tool_calls: List[str],
+    token_count: Optional[int] = None,
+    cost: Optional[float] = None,
+    timestamp: Optional[datetime] = None,
+    execution_steps: Optional[list] = None,
+    messages: Optional[list] = None,
+) -> None:
+    """Save a chat turn to history.
+
+    Appends turn to JSONL file and updates index.
+
+    Args:
+        conversation_id: Conversation ID
+        user_message: User's message
+        agent_response: Agent's response
+        tool_calls: List of tool calls made
+        token_count: Number of tokens used
+        cost: Cost of the turn
+        timestamp: Optional timestamp (defaults to now)
+        execution_steps: Optional list of execution step objects (StepResult)
+        messages: Optional full LiteLLM message history
+
+    Raises:
+        RuntimeError: If save fails
+    """
+    if timestamp is None:
+        timestamp = datetime.now(timezone.utc)
+
+    # Convert execution_steps to dicts if provided
+    steps_dicts = None
+    if execution_steps:
+        steps_dicts = []
+        for step in execution_steps:
+            if hasattr(step, "__dict__"):
+                # Convert dataclass/object to dict
+                step_dict = {
+                    "step_number": getattr(step, "step_number", None),
+                    "thought": getattr(step, "thought", ""),
+                    "code": getattr(step, "code", ""),
+                    "output": getattr(step, "output", ""),
+                    "error": getattr(step, "error", None),
+                    "tools_called": getattr(step, "tools_called", []),
+                }
+                steps_dicts.append(step_dict)
+            elif isinstance(step, dict):
+                steps_dicts.append(step)
+
+    # Create Turn model
+    turn = Turn(
+        timestamp=timestamp,
+        user=user_message,
+        assistant=agent_response,
+        tools=tool_calls,
+        tokens=token_count,
+        cost=cost,
+        steps=steps_dicts,
+        messages=messages,
+    )
+
+    save_turn_to_history(conversation_id, turn)
+
+    # Update index with cumulative stats
+    from tsugite.history import get_conversation_metadata
+
+    metadata = get_conversation_metadata(conversation_id)
+
+    if metadata:
+        # metadata is always IndexEntry
+        updated_metadata = IndexEntry(
+            agent=metadata.agent,
+            model=metadata.model,
+            machine=metadata.machine,
+            created_at=metadata.created_at,
+            updated_at=timestamp,
+            turn_count=metadata.turn_count + 1,
+            total_tokens=(metadata.total_tokens or 0) + (token_count or 0),
+            total_cost=(metadata.total_cost or 0.0) + (cost or 0.0),
+        )
+        update_index(conversation_id, updated_metadata)
+
+
+def format_conversation_for_display(turns: List[Union[ConversationMetadata, Turn]]) -> str:
+    """Format conversation turns for display.
+
+    Args:
+        turns: List of ConversationMetadata/Turn models from load_conversation()
+
+    Returns:
+        Formatted string for display
+    """
+    lines = []
+
+    for turn in turns:
+        if isinstance(turn, ConversationMetadata):
+            # Header from ConversationMetadata model
+            lines.append("=" * 60)
+            lines.append(f"Conversation: {turn.id}")
+            lines.append(f"Agent: {turn.agent}")
+            lines.append(f"Model: {turn.model}")
+            lines.append(f"Machine: {turn.machine}")
+            lines.append(f"Created: {turn.created_at}")
+            lines.append("=" * 60)
+            lines.append("")
+
+        elif isinstance(turn, Turn):
+            # Turn from Turn model
+            lines.append(f"[{turn.timestamp}]")
+            lines.append(f"User: {turn.user}")
+            lines.append("")
+            lines.append(f"Assistant: {turn.assistant}")
+
+            if turn.tools:
+                lines.append(f"  Tools: {', '.join(turn.tools)}")
+
+            # Display execution steps if available
+            if turn.steps:
+                lines.append("")
+                lines.append("  Execution Steps:")
+                for step in turn.steps:
+                    step_num = step.get("step_number", "?")
+                    thought = step.get("thought", "").strip()
+                    code = step.get("code", "").strip()
+                    output = step.get("output", "").strip()
+                    error = step.get("error")
+                    tools_called = step.get("tools_called", [])
+
+                    lines.append(f"    Step {step_num}:")
+                    if thought:
+                        lines.append(f"      Thought: {thought[:100]}{'...' if len(thought) > 100 else ''}")
+                    if tools_called:
+                        lines.append(f"      Tools: {', '.join(tools_called)}")
+                    if code:
+                        # Show first few lines of code
+                        code_lines = code.split("\n")
+                        if len(code_lines) <= 3:
+                            lines.append(f"      Code: {code}")
+                        else:
+                            lines.append(f"      Code: {code_lines[0]}")
+                            lines.append(f"            ... ({len(code_lines) - 1} more lines)")
+                    if output:
+                        output_preview = output[:150].replace("\n", " ")
+                        lines.append(f"      Output: {output_preview}{'...' if len(output) > 150 else ''}")
+                    if error:
+                        lines.append(f"      Error: {error}")
+
+            lines.append(f"  Tokens: {turn.tokens or 0} | Cost: ${turn.cost or 0.0:.4f}")
+            lines.append("")
+            lines.append("-" * 60)
+            lines.append("")
+
+    return "\n".join(lines)
+
+
+def get_latest_conversation() -> Optional[str]:
+    """Get the most recent conversation ID.
+
+    Returns:
+        Conversation ID of the most recent conversation, or None if no conversations exist
+
+    Raises:
+        RuntimeError: If query fails
+    """
+    try:
+        results = query_index(limit=1)
+        if results:
+            return results[0].get("conversation_id")
+        return None
+    except Exception as e:
+        raise RuntimeError(f"Failed to query conversation index: {e}")
+
+
+def load_conversation_history(conversation_id: str) -> List[Turn]:
+    """Load conversation history turns (without metadata).
+
+    Args:
+        conversation_id: Conversation ID to load
+
+    Returns:
+        List of Turn objects (excludes ConversationMetadata)
+
+    Raises:
+        FileNotFoundError: If conversation doesn't exist
+        RuntimeError: If load fails
+    """
+    records = load_conversation(conversation_id)
+
+    # Filter out metadata, return only Turn objects
+    return [record for record in records if isinstance(record, Turn)]