siada-cli 0.0.1__py3-none-any.whl

siada/entrypoint/interaction/turn_models.py

@@ -0,0 +1,28 @@
+from dataclasses import dataclass
+from enum import Enum
+from typing import Optional, Dict, Any
+
+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 

siada/entrypoint/siadahub.py

@@ -0,0 +1,413 @@
+import json
+import os
+import sys
+from dataclasses import fields
+from pathlib import Path
+import warnings
+
+from prompt_toolkit.completion import Completer
+
+from siada.config.config_loader import Config, load_conf
+from siada.entrypoint.args_parser.args import get_parser
+from siada.entrypoint.interaction.config import RunningConfig
+from siada.entrypoint.interaction.controller import Controller
+from siada.entrypoint.interaction.nointeractive_controller import NoInteractiveController
+from siada.foundation.logging import toggle_console_output, logger
+from siada.io.color_settings import RunningConfigColorSettings
+from siada.models.model_run_config import ModelRunConfig
+from siada.models.model_base_config import ModelBaseConfig
+from siada.support.completer import AutoCompleter
+from siada.support.slash_commands import SlashCommands, SwitchEvent
+from siada.support.envprocessor import load_dotenv_files
+from siada.support.repo import get_git_root
+from siada.utils import SettingsUtils
+from siada.io.io import InputOutput
+
+try:
+    import git
+except ImportError:
+    git = None
+
+import shtab
+from dotenv import load_dotenv
+from prompt_toolkit.enums import EditingMode
+from siada.services.model_info_service import ModelInfoService
+
+
+def _suppress_third_party_warnings():
+    """Suppress harmless warnings from third-party libraries"""
+    # Suppress pydub ffmpeg/avconv warning - not relevant for Siada as we don't use audio features
+    warnings.filterwarnings(
+        "ignore", 
+        message="Couldn't find ffmpeg or avconv.*", 
+        category=RuntimeWarning
+    )
+    
+    # Suppress all SyntaxWarning from pydub - use message pattern to catch invalid escape sequences
+    warnings.filterwarnings(
+        "ignore", 
+        message="invalid escape sequence.*", 
+        category=SyntaxWarning
+    )
+
+
+def _configure_litellm_logging():
+    """Configure LiteLLM global logging settings to suppress debug logs"""
+    try:
+        import litellm      
+
+        # Configure litellm global properties
+        litellm.set_verbose = False
+        litellm.turn_off_message_logging = True
+        litellm.suppress_debug_info = True
+        litellm.drop_params = True
+        
+        
+        # Try to disable internal debug logging
+        try:
+            litellm._logging._disable_debugging()
+        except Exception:
+            pass  # Ignore if method doesn't exist
+        
+        # Disable message logging and tracing
+        litellm.turn_off_message_logging = True
+        litellm.success_callback = []
+        litellm.failure_callback = []
+        
+        logger.debug("LiteLLM logging configuration completed")
+        
+    except ImportError:
+        logger.debug("LiteLLM not installed, skipping logging configuration")
+    except Exception as e:
+        logger.debug(f"Error configuring LiteLLM logging: {e}")
+
+
+def _parse_args_and_setup_environment(argv):
+    """
+    Parse command line arguments and set up environment
+    
+    Args:
+        argv: Command line argument list
+        
+    Returns:
+        tuple: (args, unknown, loaded_dotenvs, git_root, workspace, parser) parsed arguments, unknown arguments, loaded environment variable files, git root directory, workspace path and parser
+    """
+    # workspace is specific for development and needs to be parsed early
+    import argparse
+
+    temp_parser = argparse.ArgumentParser(add_help=False)
+    temp_parser.add_argument("--workspace", default=None)
+    temp_args, _ = temp_parser.parse_known_args(argv)
+
+    # Now get git root from the specified workspace or current directory
+    if git is None:
+        git_root = None
+    else:
+        git_root = get_git_root(temp_args.workspace)
+
+    parser = get_parser(git_root=git_root, default_config_files=[])
+    try:
+        args, unknown = parser.parse_known_args(argv)
+    except AttributeError as e:
+        raise e
+
+    # Configure console output based on parsed arguments
+    if hasattr(args, 'disable_console_output') and args.disable_console_output:
+        toggle_console_output(False)
+    else:
+        toggle_console_output(True)
+
+    loaded_dotenvs = load_dotenv_files(git_root, args.env_file, args.encoding)
+
+    if args.verbose:
+        for fname in loaded_dotenvs:
+            logger.info(f"Loaded {fname}")
+
+    return args, unknown, loaded_dotenvs, git_root, temp_args.workspace, parser
+
+
+def get_io(args, pretty=None):
+    """
+    Create InputOutput instance with complete IO configuration
+    
+    Args:
+        args: Parsed command line arguments
+        pretty: Whether to enable pretty mode, defaults to args.pretty
+        
+    Returns:
+        InputOutput: Configured IO instance
+        
+    Raises:
+        ValueError: When theme configuration is invalid
+    """
+    from siada.io.color_settings import ColorSettings
+    
+    # Configure color settings
+    color_settings = ColorSettings.from_theme(args.theme)
+    running_color_settings = RunningConfigColorSettings(color_settings=color_settings, pretty=args.pretty)
+    color_settings.apply_to_args(args)
+    if args.verbose:
+        print(f"Applied color theme: {args.theme}")
+    
+    # Configure editing mode
+    editing_mode = EditingMode.VI if args.vim else EditingMode.EMACS
+        
+    return InputOutput(
+        pretty=args.pretty,
+        running_color_settings=running_color_settings,
+        encoding=args.encoding,
+        line_endings=getattr(args, "line_endings", "platform"),
+        editingmode=editing_mode,
+        fancy_input=args.fancy_input,
+        multiline_mode=False,
+        notifications=True,
+    ), running_color_settings
+
+
+def set_env(args, io):
+    """
+    Set environment variables, including general environment variables and API keys
+    
+    Args:
+        args: Parsed command line arguments
+        io: InputOutput instance for printing error messages
+        
+    Returns:
+        int: 0 for success, 1 for error
+    """
+    # Set general environment variables
+    if args.set_env:
+        for env_setting in args.set_env:
+            try:
+                name, value = env_setting.split("=", 1)
+                os.environ[name.strip()] = value.strip()
+            except ValueError:
+                io.print_error(f"Invalid --set-env format: {env_setting}")
+                io.print_info("Format should be: ENV_VAR_NAME=value")
+                return 1
+    
+    return 0
+
+
+def get_workspace(workspace_arg, git_root):
+    """
+    Get and set workspace directory
+    
+    Args:
+        workspace_arg: User-specified workspace path
+        git_root: Git root directory path
+        
+    Returns:
+        str: Workspace path
+        
+    Raises:
+        SystemExit: When workspace directory does not exist or is not a directory
+    """
+    # Set workspace - prioritize user-specified workspace, then git root, then current directory
+    if workspace_arg:
+        workspace = os.path.abspath(workspace_arg)
+        # Ensure the workspace directory exists
+        if not os.path.exists(workspace):
+            logger.error(f"Workspace directory does not exist: {workspace}")
+            sys.exit(1)
+        if not os.path.isdir(workspace):
+            logger.error(f"Workspace path is not a directory: {workspace}")
+            sys.exit(1)
+        # Change to the specified workspace directory
+        os.chdir(workspace)
+        logger.debug(f"Changed to workspace directory: {workspace}")
+    else:
+        workspace = git_root if git_root else os.getcwd()
+        logger.debug(f"Using default workspace: {workspace}")
+    
+    return workspace
+
+
+def show_banner(io):
+    """
+    Display SIADA HUB banner with error handling
+    
+    Args:
+        io: InputOutput instance
+        
+    Raises:
+        Exception: When banner display fails
+    """
+    # Show SIADA HUB banner with gradient effect
+    from siada.io.banner import show_siada_banner
+
+    try:
+        io.rule()
+        show_siada_banner(pretty=io.pretty, console=io.console)
+    except UnicodeEncodeError as err:
+        io.print_error("Terminal does not support pretty output (UnicodeDecodeError)")
+        sys.exit(1)
+    except Exception as err:
+        io.print_error(f"Error showing banner: {err}")
+        sys.exit(1)
+
+
+def get_config(args, io, conf: Config = None):
+    """
+    Configure and create model instance
+
+    Args:
+        args: Parsed command line arguments
+        io: InputOutput instance for displaying information
+
+    Returns:
+        ModelRunConfig: Configured model instance, returns None if exit is needed
+    """
+    # Configuration priority: args > config file > defaults
+    config = ModelRunConfig.get_default_config()
+    
+    # Determine final values using priority order
+    final_model = args.model or (conf.llm_config.model if conf and conf.llm_config else None)
+    final_provider = args.provider or (conf.llm_config.provider if conf and conf.llm_config else None)
+    
+    # Apply final configuration
+    if final_model is not None:
+        config.model_name = final_model
+        config.configure_model_settings(config.model_name)
+    
+    if final_provider is not None:
+        config.provider = final_provider
+
+    # Check if provider is set
+    if config.provider is None:
+        io.print_error("No provider specified. Please set provider in agent_config.yaml or use --provider option")
+        sys.exit(1)
+
+    if config.provider == "openrouter":
+        ## check the openrouter api key is set
+        if os.getenv("OPENROUTER_API_KEY") is None:
+            io.print_error("OPENROUTER_API_KEY is not set for openrouter provider")
+            sys.exit(1)
+
+    # Set reasoning effort and thinking tokens if specified
+    if args.reasoning_effort is not None:
+        if (
+            not config.supports_extra_params
+            or "reasoning_effort" not in config.supports_extra_params
+        ):
+            io.print_error(f"Model {config.model_name} does not support reasoning effort")
+            sys.exit(1)
+        else:
+            config.set_reasoning_effort(args.reasoning_effort)
+
+    if args.thinking_tokens is not None:
+        if (
+            not config.supports_extra_params
+            or "thinking_tokens" not in config.supports_extra_params
+        ):
+            io.print_error(f"Model {config.model_name} does not support thinking tokens")
+            sys.exit(1)
+        else:
+            config.set_thinking_tokens(args.thinking_tokens)
+
+    # Display model settings in verbose mode
+    if args.verbose:
+        io.print_info("Model settings:")
+        for attr in sorted(fields(ModelRunConfig), key=lambda x: x.name):
+            value = getattr(config, attr.name)
+            if value is None:
+                val_str = "None"
+            else:
+                val_str = json.dumps(value, indent=4)
+            io.print_info(f"{attr.name}: {val_str}")
+
+    return config
+
+
+def main():
+    # Suppress harmless warnings from third-party libraries
+    _suppress_third_party_warnings()
+
+    # Configure litellm globally to suppress debug logs
+    _configure_litellm_logging()
+    
+    conf: Config = load_conf()
+
+    argv = sys.argv[1:]
+
+    args, _, _, git_root, workspace_arg, parser = _parse_args_and_setup_environment(argv)
+
+    interactive_mode = True
+    if args.prompt:
+        interactive_mode = False
+        args.pretty = False
+
+    try:
+        io, running_color_settings = get_io(args)
+    except ValueError as e:
+        print(f"Invalid theme configuration: {e}")
+        return 1
+
+    if args.list_models:
+        models = ModelInfoService.get_model_names()
+        io.print_info("\n".join(f"- {model}" for model in models))
+        return 0
+
+    # Configure model
+    model = get_config(args, io, conf)
+    # Display banner
+
+    # Set environment variables
+    if set_env(args, io) != 0:
+        return 1
+
+    # Get workspace
+    workspace = get_workspace(workspace_arg, git_root)
+
+    if args.verbose:
+        io.print_info(f"Using agent: {args.agent}")
+        io.print_info(f"Workspace: {workspace}")
+
+    if args.verbose:
+        show = SettingsUtils.format_settings(parser, args)
+        io.print_info(show)
+
+        # Show command line in verbose mode only
+        cmd_line = " ".join(sys.argv)
+        io.print_info(f"Command: {cmd_line}")
+
+    if model is None:
+        return 0
+
+    commands = SlashCommands(
+        io=io,
+        verbose=args.verbose,
+        editor=args.editor,
+    )
+
+    completer: Completer = AutoCompleter(
+        root=workspace,
+        commands=commands,
+        encoding=args.encoding,
+    )
+
+    running_config = RunningConfig(
+        llm_config=model,
+        io=io,
+        workspace=workspace,
+        agent_name=args.agent,
+        completer=completer,
+        running_color_settings=running_color_settings,
+        console_output=not args.disable_console_output if interactive_mode else True,
+        interactive=interactive_mode,
+    )
+    show_banner(io)
+
+    if not interactive_mode:
+        controller = NoInteractiveController(running_config)
+        controller.run(args.prompt)
+        return 0
+
+    controller = Controller(running_config, commands)
+    controller.show_announcements()
+    controller.run()
+
+
+if __name__ == "__main__":
+    status = main()
+    sys.exit(status)

siada/foundation/code_agent_context.py

@@ -0,0 +1,48 @@
+from typing import Optional
+from pydantic import BaseModel, ConfigDict
+
+from siada.session.session_models import RunningSession
+from typing import List
+from agents import TResponseInputItem
+from pydantic import BaseModel, Field
+
+
+class CodeAgentContext(BaseModel):
+
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    session: Optional[RunningSession] = None
+
+    root_dir: str | None = None
+
+    provider: str | None = None
+
+    # 交互模式标识，True为交互模式，False为非交互模式
+    interactive_mode: bool = True
+
+    # 完整的消息历史列表
+    message_history: List[TResponseInputItem] = Field(default_factory=list)
+
+    def add_message(self, message: TResponseInputItem) -> None:
+        self.message_history.append(message)
+
+    def add_messages(self, messages: List[TResponseInputItem]) -> None:
+        self.message_history.extend(messages)
+
+    def remove_old_messages(self, remove_count: int) -> List[TResponseInputItem]:
+        """删除旧消息，返回剩余的消息列表，永远保留第一条消息"""
+        if remove_count <= 0:
+            return self.message_history.copy()
+
+        # 如果历史记录为空或只有一条消息，不删除任何消息
+        if len(self.message_history) <= 1:
+            return self.message_history.copy()
+
+        # 计算实际可删除的消息数量（保留第一条消息）
+        max_removable = len(self.message_history) - 1
+        actual_remove_count = min(remove_count, max_removable)
+
+        # 删除第1条消息之后的N条消息（索引1到1+actual_remove_count）
+        # 保留第一条消息和剩余的消息
+        self.message_history = [self.message_history[0]] + self.message_history[1 + actual_remove_count:]
+        return self.message_history.copy()

siada/foundation/config.py

@@ -0,0 +1,59 @@
+import agents
+from pydantic_settings import BaseSettings
+from typing import Optional, ClassVar
+
+
+class Settings(BaseSettings):
+    """
+    应用配置类
+    
+    使用pydantic_settings管理配置，支持从环境变量加载
+    """
+    # 应用基本信息
+    APP_NAME: str = "Siada API"
+    APP_VERSION: str = "0.1.0"
+    APP_DESCRIPTION: str = "提供Siada agent对外的RPC能力"
+
+    # API配置
+    API_PREFIX: str = "/api/v1"
+
+    # 服务器配置
+    HOST: str = "0.0.0.0"
+    PORT: int = 8000
+    RELOAD: bool = True
+
+    # 日志配置
+    LOG_LEVEL: str = "INFO"
+
+    # OpenAI API配置
+    OPENAI_API_KEY: Optional[str] = None
+    OPENAI_API_BASE: Optional[str] = None
+    OPENAI_API_VERSION: Optional[str] = None
+    OPENAI_API_TYPE: Optional[str] = None
+    OPENAI_ORGANIZATION: Optional[str] = None
+
+    # Agent配置
+    Claude_4_0_SONNET: str = "claude-sonnet-4"
+    Gemini_2_5_PRO: str = "gemini-2.5-pro"
+    Deepseek_V3_0324: str = "deepseek-v3-0324"
+    Deepseek_R1_0528: str = "deepseek-r1-0528"
+    O1_MINI: str = "o1-mini"
+    MAX_TURNS: int = 200
+    DEFAULT_MODEL: str = Claude_4_0_SONNET
+
+
+    # 将RunConfig设置为ClassVar，这样它不会被包含在模型验证中
+    _DEFAULT_RUN_CONFIG: ClassVar[agents.RunConfig] = None
+
+    class Config:
+        env_file = ".env"
+        case_sensitive = True
+
+    class Constants:
+        # Agent名称
+        JANK_PROBLEM_AGENT_NAME: str = "JankProblemAgent"
+
+
+# 创建全局设置对象
+settings = Settings()
+settings.model_rebuild()  # 确保模型完全构建

siada/foundation/constants.py

@@ -0,0 +1,2 @@
+LLM_API_CONNECT_TIMEOUT = 30  # timeout for connecting to the API and sending the request (seconds)
+LLM_API_READ_TIMEOUT = 600  # timeout for receiving the response (seconds)

siada/foundation/context.py

@@ -0,0 +1,76 @@
+"""
+上下文管理模块
+
+提供全局上下文管理功能，类似于Java中的ThreadLocal
+支持存储多种类型的上下文变量
+"""
+import contextvars
+from typing import Any, Dict, Optional
+
+# 创建上下文变量字典
+context_dict_var = contextvars.ContextVar('context_dict', default={})
+
+def set_context_var(key: str, value: Any) -> None:
+    """
+    设置上下文变量
+    
+    Args:
+        key: 变量名
+        value: 变量值
+    """
+    context_dict = context_dict_var.get()
+    new_dict = dict(context_dict)  # 创建副本以避免修改原始字典
+    new_dict[key] = value
+    context_dict_var.set(new_dict)
+
+def get_context_var(key: str, default: Any = None) -> Any:
+    """
+    获取上下文变量
+    
+    Args:
+        key: 变量名
+        default: 默认值，如果变量不存在则返回此值
+        
+    Returns:
+        上下文变量值，如果不存在则返回默认值
+    """
+    context_dict = context_dict_var.get()
+    return context_dict.get(key, default)
+
+def remove_context_var(key: str) -> None:
+    """
+    移除上下文变量
+    
+    Args:
+        key: 变量名
+    """
+    context_dict = context_dict_var.get()
+    new_dict = dict(context_dict)  # 创建副本以避免修改原始字典
+    if key in new_dict:
+        del new_dict[key]
+    context_dict_var.set(new_dict)
+
+def clear_context() -> None:
+    """
+    清空所有上下文变量
+    """
+    context_dict_var.set({})
+
+# 为了保持向后兼容性，提供session_id的专用方法
+def set_session_id(session_id: str) -> None:
+    """
+    设置当前上下文的session_id
+    
+    Args:
+        session_id: 会话ID
+    """
+    set_context_var('session_id', session_id)
+
+def get_session_id() -> Optional[str]:
+    """
+    获取当前上下文的session_id
+    
+    Returns:
+        当前上下文的session_id，如果不存在则返回None
+    """
+    return get_context_var('session_id')