siada-cli 0.0.1__py3-none-any.whl

siada/agent_hub/siada_agent.py

@@ -0,0 +1,214 @@
+from abc import ABC, abstractmethod
+from typing import Generic
+import yaml
+import os
+
+from agents import Agent, RunConfig, RunHooks, RunResult, RunResultStreaming, Runner, TContext, TResponseInputItem, set_trace_processors
+from siada.agent_hub.coder.tracing.logger_tracing_processor import create_detailed_logger
+from siada.foundation.code_agent_context import CodeAgentContext
+from siada.models.converter import ModelSettingsConverter
+from siada.provider.provider_factory import get_provider
+from siada.session import RunningSessionManager
+from siada.tools.coder.ask_followup_question import ask_followup_question
+from siada.tools.coder.repo_map.repo_map import RepoMap
+from siada.tools.coder.repo_map.token_counter import TokenCounterModel
+from siada.tools.coder.repo_map.io import SilentIO
+
+import logging
+
+class SiadaAgent(Agent[Generic[TContext]], ABC):
+
+    @abstractmethod
+    async def get_context(self) -> TContext:
+        """
+        Get the context object for this agent.
+        
+        Returns:
+            TContext: The context object containing relevant information for the agent's execution.
+        """
+        pass
+
+    @abstractmethod
+    async def run(self, user_input: str, context: TContext) -> RunResult:
+        """
+        Execute the agent with the given user input and context.
+        
+        Args:
+            user_input (str): The input provided by the user.
+            context (TContext): The context object containing relevant information for execution.
+            
+        Returns:
+            RunResult: The result of the agent's execution.
+        """
+        pass
+
+    @abstractmethod
+    async def run_streamed(self, user_input: str, context: TContext) -> RunResultStreaming:
+        """
+        Execute Streamed the agent with the given user input and context
+                
+        Args:
+            user_input (str): The input provided by the user.
+            context (TContext): The context object containing relevant information for execution.
+            
+        Returns:
+            RunResultStreaming: The stream result of the agent's execution.
+        """
+        pass
+
+    def get_interactive_mode(self) -> bool:
+        """
+        获取当前的交互模式状态
+        
+        Returns:
+            bool: True为交互模式，False为非交互模式
+        """
+        # 检查是否有--prompt参数，如果有则为非交互模式
+        import sys
+        return '--prompt' not in sys.argv and '-p' not in sys.argv
+
+    def get_repo_map_model_name(self) -> str:
+        """
+        Get the model name used for repo map generation
+        
+        Returns:
+            str: Model name, defaults to claude-sonnet-4
+        """
+        try:
+            # Read configuration file
+            config_path = os.path.join(os.getcwd(), "agent_config.yaml")
+            if os.path.exists(config_path):
+                with open(config_path, 'r', encoding='utf-8') as f:
+                    config = yaml.safe_load(f)
+                    llm_config = config.get('llm_config', {})
+                    return llm_config.get('model_name', 'claude-sonnet-4')
+        except Exception as e:
+            logging.warning(f"Failed to read agent config file for repo map model name: {str(e)}")
+
+        # If reading configuration fails, use default value
+        return 'claude-sonnet-4'
+
+    def get_repo_map_instance(self, root_dir: str):
+        """
+        Get RepoMap instance
+        
+        Args:
+            root_dir (str): Repository root directory
+            
+        Returns:
+            RepoMap: Configured RepoMap instance
+        """
+        try:
+
+            # Read configuration
+            config_path = os.path.join(os.getcwd(), "agent_config.yaml")
+            llm_config = {}
+            if os.path.exists(config_path):
+                try:
+                    with open(config_path, 'r', encoding='utf-8') as f:
+                        config = yaml.safe_load(f)
+                        llm_config = config.get('llm_config', {})
+                except Exception as e:
+                    logging.warning(f"Failed to read agent config file for repo map instance: {str(e)}")
+
+            # Get configuration parameters
+            model_name = llm_config.get('model_name', 'claude-sonnet-4')
+            repo_map_tokens = llm_config.get('repo_map_tokens', 8192)
+            repo_map_mul_no_files = llm_config.get('repo_map_mul_no_files', 16)
+            repo_verbose = llm_config.get('repo_verbose', True)
+
+            # Create components
+            token_counter = TokenCounterModel(model_name)
+            io = SilentIO()  # Use silent IO to avoid output interference
+
+            return RepoMap(
+                root=root_dir,
+                main_model=token_counter,
+                io=io,
+                verbose=repo_verbose,
+                map_tokens=repo_map_tokens,
+                map_mul_no_files=repo_map_mul_no_files
+            )
+        except Exception as e:
+            logging.warning(f"Failed to create RepoMap instance for root directory '{root_dir}': {str(e)}")
+            # If creation fails, return None
+            return None
+
+    async def prepare_run_environment(
+        self,
+        context: TContext | None = None,
+    ):
+        running_session = context.session
+        if running_session is None:
+            running_session = RunningSessionManager.get_default_session()
+            context.session = running_session
+
+        llm_config = running_session.siada_config.llm_config
+        model_settings = ModelSettingsConverter.convert_model_settings(llm_config)
+        model_provider_name = llm_config.provider
+        model_provider = get_provider(model_provider_name)
+        
+        # Store provider name (string) in context for client factory
+        context.provider = model_provider_name
+
+        # if running_session.running_config.interactive:
+        #     ## in the interactive mode, we need to add the ask_followup_question tool
+        #     if ask_followup_question not in self.tools:
+        #         self.tools.append(ask_followup_question)
+
+        run_config = RunConfig(
+            tracing_disabled=running_session.siada_config.tracing_disabled,
+            model=llm_config.model_name,
+            model_provider=model_provider,
+            model_settings=model_settings
+        )
+
+        session = running_session.state.openai_session
+        return run_config, session
+
+    async def run_impl(
+        self,
+        starting_agent: Agent[TContext],
+        input: str | list[TResponseInputItem],
+        context: TContext | None = None,
+        max_turns: int = 10,
+        hooks: RunHooks[TContext] | None = None,
+        previous_response_id: str | None = None,
+    ) -> RunResult:
+
+        run_config, session = await self.prepare_run_environment(context)
+
+        return await Runner.run(
+            starting_agent=starting_agent,
+            input=input,
+            context=context,
+            max_turns=max_turns,
+            hooks=hooks,
+            run_config=run_config,
+            previous_response_id=previous_response_id,
+            session=session,
+        )
+
+    async def run_streamed_impl(
+        self,
+        starting_agent: Agent[TContext],
+        input: str | list[TResponseInputItem],
+        context: TContext | None = None,
+        max_turns: int = 10,
+        hooks: RunHooks[TContext] | None = None,
+        run_config: RunConfig | None = None,
+        previous_response_id: str | None = None,
+    ) -> RunResultStreaming:
+
+        run_config, session = await self.prepare_run_environment(context)
+
+        return Runner.run_streamed(
+            starting_agent=starting_agent,
+            input=input,
+            context=context,
+            max_turns=max_turns,
+            hooks=hooks,
+            run_config=run_config,
+            previous_response_id=previous_response_id,
+            session=session,
+        )

siada/config/config_loader.py

@@ -0,0 +1,67 @@
+
+
+
+
+
+
+import os
+import yaml
+from dataclasses import dataclass, asdict, field
+from pathlib import Path
+from typing import Optional, Dict, Any
+
+
+@dataclass(frozen=True)
+class LLMConfig:
+    """LLM configuration class"""
+    model: Optional[str] = None
+    provider: Optional[str] = None
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> 'LLMConfig':
+        """Create LLMConfig instance from dictionary"""
+        return cls(
+            model=data.get('model'),
+            provider=data.get('provider')
+        )
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary"""
+        return asdict(self)
+
+
+def _get_default_config_path() -> Path:
+    """Get default configuration file path"""
+    home_dir = Path.home()
+    return home_dir / '.siada-cli' / 'conf.yaml'
+
+@dataclass(frozen=True)
+class Config:
+    """Main configuration class (immutable)"""
+    llm_config: LLMConfig = field(default_factory=LLMConfig)
+
+def load_conf(config_path: Optional[Path] = None) -> 'Config':
+    """Load configuration from YAML file"""
+    if config_path is None:
+        config_path = _get_default_config_path()
+    
+    llm_config = LLMConfig()
+    
+    try:
+        if config_path.exists():
+            with open(config_path, 'r', encoding='utf-8') as file:
+                data = yaml.safe_load(file) or {}
+                
+                # Load LLM configuration
+                if 'llm_config' in data:
+                    llm_config = LLMConfig.from_dict(data['llm_config'])
+        # If config file doesn't exist, return default values without creating directories
+            
+    except yaml.YAMLError as e:
+        print(f"Warning: Configuration file format error: {e}")
+    except Exception as e:
+        print(f"Warning: Failed to load configuration file: {e}")
+    
+    return Config(llm_config=llm_config)
+
+

siada/entrypoint/__init__.py

@@ -0,0 +1,3 @@
+"""
+Siada Hub 命令行工具入口点
+"""

siada/entrypoint/args_parser/args.py

@@ -0,0 +1,195 @@
+#!/usr/bin/env python
+
+import argparse
+import os
+import sys
+from pathlib import Path
+
+import configargparse
+import shtab
+
+from siada import __version__
+from siada.services.siada_runner import SiadaRunner
+
+
+def default_env_file(git_root):
+    return os.path.join(git_root, ".env") if git_root else ".env"
+
+
+def get_parser(default_config_files, git_root):
+    parser = configargparse.ArgumentParser(
+        description="Siada-CLI is AI pair programming in your terminal",
+        add_config_file_help=True,
+        default_config_files=default_config_files,
+        config_file_parser_class=configargparse.YAMLConfigFileParser,
+        auto_env_var_prefix="SIADA_",
+    )
+
+    # Load agent configurations from config file
+    try:
+        agent_configs = SiadaRunner._load_agent_config()
+        # Get enabled agent types for choices
+        agent_choices = [name for name, config in agent_configs.items() 
+                        if config.get('enabled', False) and config.get('class')]
+    except Exception as e:
+        # Fallback to default if config loading fails
+        agent_configs = {}
+        agent_choices = ['bugfix', 'coder', 'fegen', 'bugreproduce']
+        print(f"Warning: Failed to load agent config, using defaults: {e}")
+
+    ##########
+    group = parser.add_argument_group("agent config")
+
+    group.add_argument(
+        "--agent",
+        "-a",
+        metavar="AGENT",
+        choices=agent_choices,
+        default="coder",
+        help=f"Specify the agent type to use (choices: {', '.join(agent_choices)}, default: coder)",
+    )
+
+    # Generate individual agent command arguments
+    for agent_name in agent_choices:
+        agent_config = agent_configs.get(agent_name, {})
+        description = agent_config.get('description', f'{agent_name.title()} agent')
+
+        group.add_argument(
+            f"--{agent_name}",
+            action="store_const",
+            dest="agent",
+            const=agent_name,
+            help=f"Use {description}",
+        )
+
+    ##########
+    group = parser.add_argument_group("prompt config")
+    group.add_argument(
+        "--prompt",
+        "-p",
+        metavar="PROMPT",
+        default=None,
+        help="Specify the prompt, if provided, it will be activated for the no interaction mode",
+    )
+
+    ##########
+    group = parser.add_argument_group("API Keys and settings")
+    group.add_argument(
+        "--env-file",
+        metavar="ENV_FILE",
+        default=default_env_file(git_root),
+        help="Specify the .env file to load (default: .env in git root)",
+    ).complete = shtab.FILE
+
+    group.add_argument(
+        "--set-env",
+        action="append",
+        metavar="ENV_VAR_NAME=value",
+        help="Set an environment variable (to control API settings, can be used multiple times)",
+        default=[],
+    )
+
+    group = parser.add_argument_group("Model settings")
+
+    group.add_argument(
+        "--model",
+        metavar="MODEL",
+        default=None,
+        help="Specify the model to use for the main chat",
+    )
+
+    group.add_argument(
+        "--list-models",
+        "--models",
+        action="store_true",
+        help="List all available models",
+    )
+
+    group.add_argument(
+        "--reasoning-effort",
+        type=str,
+        help="Set the reasoning_effort API parameter (default: not set)",
+    )
+    group.add_argument(
+        "--thinking-tokens",
+        type=str,
+        help=(
+            "Set the thinking token budget for models that support it. Use 0 to disable. (default:"
+            " not set)"
+        ),
+    )
+
+    group.add_argument(
+        "--provider",
+        choices=["openrouter", "li"],
+        default=None,
+        help="Specify the provider to use for the main chat (choices: openrouter, li, default: li)",
+        metavar="PROVIDER",
+    )
+
+    group = parser.add_argument_group("Output settings")
+    group.add_argument(
+        "--theme",
+        choices=["default", "dark", "light"],
+        default="dark",
+        help="Select color theme: default, dark, or light (default: None, auto-detect or use individual mode flags)",
+    )
+
+    group.add_argument(
+        "--pretty",
+        action=argparse.BooleanOptionalAction,
+        default=True,
+        help="Enable/disable pretty, colorized output (default: True)",
+    )
+
+    group.add_argument(
+        "--fancy-input",
+        action=argparse.BooleanOptionalAction,
+        default=True,
+        help="Enable/disable fancy input (default: True)",
+    )
+
+    group = parser.add_argument_group("Upgrading")
+    group.add_argument(
+        "--version",
+        action="version",
+        version=f"%(prog)s {__version__}",
+        help="Show the version number and exit",
+    )
+
+    ######
+    group = parser.add_argument_group("Other settings")
+
+    group.add_argument(
+        "--vim",
+        action="store_true",
+        help="Use VI editing mode in the terminal (default: False)",
+        default=False,
+    )
+    group.add_argument(
+        "-v",
+        "--verbose",
+        action="store_true",
+        help="Enable verbose output",
+        default=False,
+    )
+
+    group.add_argument(
+        "--encoding",
+        default="utf-8",
+        help="Specify the encoding for input and output (default: utf-8)",
+    )
+
+    group.add_argument(
+        "--editor",
+        help="Specify which editor to use for the /editor command",
+    )
+
+    group.add_argument(
+        "--disable-console-output",
+        action=argparse.BooleanOptionalAction,
+        default=True,
+        help="Disable console output for debugging (default: True)",
+    )
+
+    return parser

siada/entrypoint/interaction/base_turn.py

@@ -0,0 +1,107 @@
+from abc import ABC, abstractmethod
+from typing import Optional, Any
+import traceback
+
+from siada.entrypoint.interaction.config import RunningConfig
+from siada.entrypoint.interaction.turn_models import TurnInput, TurnOutput, TurnType
+
+
+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
+        
+        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/config.py

@@ -0,0 +1,30 @@
+"""
+Configuration classes for interaction module
+"""
+
+from dataclasses import dataclass
+from typing import Optional
+from rlcompleter import Completer
+
+from siada.io.color_settings import RunningConfigColorSettings
+from siada.io.io import InputOutput
+from siada.models.model_run_config import ModelRunConfig
+
+
+@dataclass
+class RunningConfig:
+    """Configuration data class for interaction controller"""
+
+    # Required fields (no default values)
+    llm_config: ModelRunConfig
+    io: InputOutput
+    workspace: str
+    agent_name: str
+    
+    # Optional fields (with default values)
+    completer: Optional[Completer] = None
+    running_color_settings: Optional[RunningConfigColorSettings] = None
+    max_turns: int = 10
+    tracing_disabled: bool = False
+    console_output: bool = False
+    interactive: bool = True