siada-cli 0.0.1__py3-none-any.whl

siada/entrypoint/interaction/controller.py

@@ -0,0 +1,122 @@
+"""
+Interaction Controller Module
+
+Manages the AI coding interaction lifecycle and controls the main interaction flow.
+Separates core interaction logic from main entry point for better code organization.
+"""
+
+from dataclasses import dataclass
+
+import siada.support.completer
+from siada import __version__
+from siada.entrypoint.interaction.config import RunningConfig
+from siada.entrypoint.interaction.turn.run_turn import TurnFactory, TurnInput
+from siada.io.io import InputOutput
+from siada.models.model_run_config import ModelRunConfig
+from siada.session.session_manager import RunningSessionManager
+from siada.support.slash_commands import SlashCommands, SwitchEvent
+from rich.console import Console
+
+import time
+import sys
+
+
+class Controller:
+    """Controls user-AI coding interactions and manages coder lifecycle"""
+
+    def __init__(self, config: RunningConfig, slash_commands: SlashCommands, shell_mode: bool = False):
+        self.config = config
+        self.slash_commands = slash_commands
+        self.shell_mode = shell_mode
+        self.last_keyboard_interrupt = None
+
+    def run(self) -> int:
+        session = RunningSessionManager.create_session(
+            siada_config=self.config,
+        )
+        display_rule = True
+        while True:
+            try:
+                user_input = self.config.io.get_input(
+                    completer=self.config.completer if not self.shell_mode else None,
+                    display_rule=display_rule,
+                    color=(
+                        self.config.running_color_settings.user_input_color
+                        if not self.shell_mode
+                        else self.config.running_color_settings.shell_model_color
+                    ),
+                )
+
+                display_rule = True
+                if user_input.strip() == "":
+                    display_rule = False
+                    continue
+
+                if self.shell_mode and user_input.strip() in ["exit", "quit"]:
+                    # exit the shell mode
+                    self.shell_mode = False
+                    self.config.io.print_info("Switching to agent mode...")
+                    continue
+
+                if self.shell_mode:
+                    user_input = f"!{user_input}"
+
+                turn = TurnFactory.create_turn(
+                    self.config, session, self.slash_commands, user_input
+                )
+                turn_output = turn.execute(TurnInput(use_input=user_input))
+
+                if isinstance(turn_output.output, SwitchEvent):
+                    if turn_output.output.kwargs.get("agent"):
+
+                        self.config.agent_name = turn_output.output.kwargs.get("agent")
+                        # clear the session to avoid the previous agent's messages
+                        session.state.openai_session.clear_session()
+
+                    elif turn_output.output.kwargs.get("model"):
+                        self.config.model = turn_output.output.kwargs.get("model")
+                    # show the announcements in every switch event
+                    if turn_output.output.kwargs.get("shell"):
+                        self.shell_mode = True
+                    self.show_announcements()
+            except KeyboardInterrupt as e:
+                self.keyboard_interrupt()
+                break
+            except Exception as e:
+                self.config.io.print_error(e)
+                break
+
+    def get_announcements(self):
+        lines = []
+        lines.append(f"Siada CLI v{__version__}")
+
+        output = f"Agent: {self.config.agent_name}, Provider: {self.config.llm_config.provider}, Model: {self.config.llm_config.model_name}"
+
+        # Check for thinking token budget
+        thinking_tokens = self.config.llm_config.get_thinking_tokens()
+        if thinking_tokens:
+            output += f", {thinking_tokens} think tokens"
+
+        # Check for reasoning effort
+        reasoning_effort = self.config.llm_config.get_reasoning_effort()
+        if reasoning_effort:
+            output += f", reasoning {reasoning_effort}"
+
+        if self.shell_mode:
+            output += ", shell mode"
+        else:
+            output += ", agent mode"
+
+        lines.append(output)
+        return lines
+
+    def show_announcements(self):
+        for line in self.get_announcements():
+            self.config.io.print_info(line)
+
+    def keyboard_interrupt(self):
+        # Ensure cursor is visible on exit
+        Console().show_cursor(True)
+
+        self.config.io.print_warning("\n\n^C KeyboardInterrupt")
+        sys.exit()

siada/entrypoint/interaction/nointeractive_controller.py

@@ -0,0 +1,27 @@
+import asyncio
+from unittest import result
+from siada.entrypoint.interaction.config import RunningConfig
+from siada.services.siada_runner import SiadaRunner
+from siada.session.session_manager import RunningSessionManager
+
+
+class NoInteractiveController:
+    """Controls user-AI coding interactions and manages coder lifecycle"""
+
+    def __init__(self, config: RunningConfig):
+        self.config = config
+
+    def run(self, user_input: str) -> int:
+        session = RunningSessionManager.create_session(
+            siada_config=self.config,
+        )
+        result = asyncio.run(
+            SiadaRunner.run_agent(
+                agent_name=self.config.agent_name,
+                user_input=user_input,
+                workspace=self.config.workspace,
+                session=session,
+            )
+        )
+        self.config.io.print(result)
+        return 0

siada/entrypoint/interaction/turn/interface.py

@@ -0,0 +1,116 @@
+"""
+Turn Interface Module
+
+Contains abstract base classes and interfaces for interaction turns.
+"""
+
+from typing import Optional, Any
+from abc import ABC, abstractmethod
+
+from agents import TResponseInputItem
+
+# Import existing config and models
+from ..config import RunningConfig
+from .models import TurnType, TurnInput, TurnOutput
+
+
+class RunTurn(ABC):
+    """Abstract base class for interaction turns"""
+
+    def __init__(self, config: RunningConfig, session: Any, slash_commands: Any):
+        """Initialize turn with configuration and session
+
+        Args:
+            config: InteractionConfig with execution parameters
+            session: Current session instance
+        """
+        self.config = config
+        self.session = session
+        self.slash_commands = slash_commands
+
+        # Data tracking
+        self.input_data: Optional[TurnInput] = None
+        self.output_data: Optional[TurnOutput] = None
+        self.start_time: Optional[float] = None
+        self.end_time: Optional[float] = None
+        self.error: Optional[Exception] = None
+
+    @abstractmethod
+    def execute(self, turn_input: TurnInput) -> TurnOutput:
+        """Execute the turn with given input
+
+        Args:
+            turn_input: Input data for this turn
+
+        Returns:
+            TurnOutput: Result of turn execution
+        """
+        pass
+
+    def can_handle(self, user_input: str) -> bool:
+        """Check if this turn type can handle the given input
+
+        Args:
+            user_input: Raw user input string
+
+        Returns:
+            bool: True if this turn can handle the input
+        """
+        return True
+
+    def prepare_input(self, raw_input: str) -> TurnInput:
+        """Prepare turn input from raw user input
+
+        Args:
+            raw_input: Raw user input string
+
+        Returns:
+            TurnInput: Prepared input for turn execution
+        """
+        return TurnInput(use_input=raw_input)
+
+    def get_turn_type(self) -> TurnType:
+        """Get the type of this turn
+
+        Returns:
+            TurnType: Type of this turn
+        """
+        return TurnType.CONVERSATION
+
+    def validate_input(self, turn_input: TurnInput) -> bool:
+        """Validate turn input
+
+        Args:
+            turn_input: Input to validate
+
+        Returns:
+            bool: True if input is valid
+        """
+        return bool(turn_input.use_input and turn_input.use_input.strip())
+
+    def handle_error(self, error: Exception) -> TurnOutput:
+        """Handle execution error
+
+        Args:
+            error: Exception that occurred
+
+        Returns:
+            TurnOutput: Error response
+        """
+        self.error = error
+        
+        # Print full error traceback for debugging
+        import traceback
+        full_traceback = traceback.format_exc()
+        self.config.io.print_error(f"Error occurred: {str(error)}\n\nFull traceback:\n{full_traceback}")
+        return TurnOutput(
+            output=f"Error: {str(error)}",
+            metadata={"error_type": type(error).__name__},
+            next_action=None,
+        )
+
+    def _get_timestamp(self) -> float:
+        """Get current timestamp"""
+        import time
+
+        return time.time()

siada/entrypoint/interaction/turn/models.py

@@ -0,0 +1,34 @@
+"""
+Turn Models Module
+
+Contains data models and type definitions for interaction turns.
+"""
+
+from typing import Optional, Dict, Any
+from dataclasses import dataclass
+from enum import Enum
+
+from siada.support.slash_commands import SwitchEvent
+
+
+class TurnType(Enum):
+    """Types of interaction turns"""
+
+    COMMAND = "command"  # Slash commands (/help, /edit, etc.)
+    CONVERSATION = "conversation"  # Regular AI conversation
+
+
+@dataclass
+class TurnInput:
+    """Input data for a turn"""
+
+    use_input: str  # Raw user input
+
+
+@dataclass
+class TurnOutput:
+    """Output data from a turn"""
+
+    output: str | SwitchEvent  # Response content
+    metadata: Dict[str, Any]  # Response metadata
+    next_action: Optional[str]  # Suggested next action