tunacode-cli 0.1.21__py3-none-any.whl

tunacode/types/dataclasses.py

@@ -0,0 +1,121 @@
+"""Dataclass definitions for TunaCode CLI.
+
+Contains structured data types used throughout the application.
+"""
+
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from tunacode.types.state import StateManagerProtocol
+
+
+@dataclass
+class ModelPricing:
+    """Pricing information for a model."""
+
+    input: float
+    cached_input: float
+    output: float
+
+
+@dataclass
+class ModelConfig:
+    """Configuration for a model including pricing."""
+
+    pricing: ModelPricing
+
+
+ModelRegistry = dict[str, ModelConfig]
+
+
+@dataclass
+class ToolConfirmationRequest:
+    """Request for tool execution confirmation."""
+
+    tool_name: str
+    args: dict[str, Any]
+    filepath: str | None = None
+    diff_content: str | None = None
+
+
+@dataclass
+class ToolConfirmationResponse:
+    """Response from tool confirmation dialog."""
+
+    approved: bool
+    skip_future: bool = False
+    abort: bool = False
+    instructions: str = ""
+
+
+@dataclass
+class ResponseState:
+    """Track whether a user visible response was produced."""
+
+    has_user_response: bool = False
+    has_final_synthesis: bool = False
+    task_completed: bool = False
+    awaiting_user_guidance: bool = False
+
+
+@dataclass
+class FallbackResponse:
+    """Structure for synthesized fallback responses."""
+
+    summary: str
+    progress: str = ""
+    issues: list[str] = field(default_factory=list)
+    next_steps: list[str] = field(default_factory=list)
+
+
+class AgentState(Enum):
+    """Agent loop states for enhanced completion detection."""
+
+    USER_INPUT = "user_input"
+    ASSISTANT = "assistant"
+    TOOL_EXECUTION = "tool_execution"
+    RESPONSE = "response"
+
+
+@dataclass
+class CommandContext:
+    """Context passed to command handlers."""
+
+    state_manager: "StateManagerProtocol"
+    process_request: Any | None = None
+
+
+@dataclass
+class TokenUsage:
+    """Token usage for a request."""
+
+    input_tokens: int
+    cached_tokens: int
+    output_tokens: int
+
+
+@dataclass
+class CostBreakdown:
+    """Breakdown of costs for a request."""
+
+    input_cost: float
+    cached_cost: float
+    output_cost: float
+    total_cost: float
+
+
+__all__ = [
+    "AgentState",
+    "CommandContext",
+    "CostBreakdown",
+    "FallbackResponse",
+    "ModelConfig",
+    "ModelPricing",
+    "ModelRegistry",
+    "ResponseState",
+    "TokenUsage",
+    "ToolConfirmationRequest",
+    "ToolConfirmationResponse",
+]

tunacode/types/pydantic_ai.py

@@ -0,0 +1,31 @@
+"""Pydantic-AI type wrappers for TunaCode CLI.
+
+Isolates pydantic-ai dependencies to a single module for easier
+migration if the underlying library changes.
+"""
+
+from typing import Any
+
+from pydantic_ai import Agent
+from pydantic_ai.messages import ModelRequest as _ModelRequest
+from pydantic_ai.messages import ToolReturnPart
+
+# Re-export with stable names ugly but better thab what we had before
+PydanticAgent = Agent
+MessagePart = ToolReturnPart | Any
+ModelRequest = _ModelRequest
+ModelResponse = Any
+
+AgentResponse = Any
+MessageHistory = list[Any]
+AgentRun = Any
+
+__all__ = [
+    "AgentResponse",
+    "AgentRun",
+    "MessageHistory",
+    "MessagePart",
+    "ModelRequest",
+    "ModelResponse",
+    "PydanticAgent",
+]

tunacode/types/state.py

@@ -0,0 +1,122 @@
+"""State management protocol for TunaCode CLI.
+
+Defines the StateManager protocol to enable type-safe usage without
+creating circular imports with the concrete implementation.
+"""
+
+from typing import TYPE_CHECKING, Any, Protocol
+
+if TYPE_CHECKING:
+    from tunacode.types.callbacks import ToolProgressCallback
+
+
+class SessionStateProtocol(Protocol):
+    """Protocol for session state access."""
+
+    user_config: dict[str, Any]
+    current_model: str
+    tool_progress_callback: "ToolProgressCallback | None"
+    messages: list[Any]
+    tool_calls: list[dict[str, Any]]
+    tool_ignore: list[str]
+    yolo: bool
+    show_thoughts: bool
+    operation_cancelled: bool
+    total_tokens: int
+    max_tokens: int
+    # Persistence fields
+    project_id: str
+    created_at: str
+    working_directory: str
+
+    def update_token_count(self) -> None:
+        """Calculate total token count from conversation messages."""
+        ...
+
+
+class StateManagerProtocol(Protocol):
+    """Protocol defining the StateManager interface.
+
+    This protocol enables type-safe references to StateManager without
+    importing the concrete implementation, avoiding circular imports.
+    """
+
+    @property
+    def session(self) -> SessionStateProtocol:
+        """Access the current session state."""
+        ...
+
+    @property
+    def tool_handler(self) -> Any:
+        """Get the current tool handler."""
+        ...
+
+    def set_tool_handler(self, handler: Any) -> None:
+        """Set the tool handler instance."""
+        ...
+
+    # ReAct scratchpad methods
+    def get_react_scratchpad(self) -> dict[str, Any]:
+        """Get the ReAct scratchpad dictionary."""
+        ...
+
+    def append_react_entry(self, entry: dict[str, Any]) -> None:
+        """Append an entry to the ReAct timeline."""
+        ...
+
+    def clear_react_scratchpad(self) -> None:
+        """Clear the ReAct scratchpad."""
+        ...
+
+    # Todo list methods
+    def get_todos(self) -> list[dict[str, Any]]:
+        """Get the current todo list."""
+        ...
+
+    def set_todos(self, todos: list[dict[str, Any]]) -> None:
+        """Replace the entire todo list."""
+        ...
+
+    def clear_todos(self) -> None:
+        """Clear the todo list."""
+        ...
+
+    # Recursive execution methods
+    def push_recursive_context(self, context: dict[str, Any]) -> None:
+        """Push a context onto the recursive stack."""
+        ...
+
+    def pop_recursive_context(self) -> dict[str, Any] | None:
+        """Pop and return the top context."""
+        ...
+
+    def can_recurse_deeper(self) -> bool:
+        """Check if recursion limit allows deeper nesting."""
+        ...
+
+    def reset_recursive_state(self) -> None:
+        """Reset all recursive execution state."""
+        ...
+
+    # Session persistence methods
+    def save_session(self) -> bool:
+        """Save current session to disk."""
+        ...
+
+    def load_session(self, session_id: str) -> bool:
+        """Load a session from disk by ID."""
+        ...
+
+    def list_sessions(self) -> list[dict[str, Any]]:
+        """List available saved sessions."""
+        ...
+
+
+# Backward compatibility alias
+StateManager = StateManagerProtocol
+
+__all__ = [
+    "SessionStateProtocol",
+    "StateManager",
+    "StateManagerProtocol",
+]

tunacode/ui/__init__.py

@@ -0,0 +1,6 @@
+"""TunaCode UI layer - Textual-based TUI."""
+
+from .app import TextualReplApp
+from .repl_support import run_textual_repl
+
+__all__ = ["TextualReplApp", "run_textual_repl"]