siada-cli 0.0.1__py3-none-any.whl

siada/io/key_bindings.py

@@ -0,0 +1,129 @@
+import functools
+import signal
+
+from prompt_toolkit.enums import EditingMode
+from prompt_toolkit.filters import Condition, is_searching, has_completions
+from prompt_toolkit.key_binding import KeyBindings
+from prompt_toolkit.key_binding.vi_state import InputMode
+from prompt_toolkit.keys import Keys
+
+from siada.support.editor import pipe_editor
+
+
+class KeyBindingsFactory:
+    """A factory for creating key bindings for the IO instance."""
+    def __init__(self, io_instance):
+        self.io = io_instance
+
+    def create_key_bindings(self):
+        kb = KeyBindings()
+
+        def suspend_to_bg(event):
+            """Suspend currently running application."""
+            event.app.suspend_to_background()
+
+        @kb.add(Keys.ControlZ, filter=Condition(lambda: hasattr(signal, "SIGTSTP")))
+        def _(event):
+            "Suspend to background with ctrl-z"
+            suspend_to_bg(event)
+
+        @kb.add("c-space")
+        def _(event):
+            "Ignore Ctrl when pressing space bar"
+            event.current_buffer.insert_text(" ")
+
+        @kb.add("c-up")
+        def _(event):
+            "Navigate backward through history"
+            event.current_buffer.history_backward()
+
+        @kb.add("c-down")
+        def _(event):
+            "Navigate forward through history"
+            event.current_buffer.history_forward()
+
+        @kb.add("c-x", "c-e")
+        def _(event):
+            "Edit current input in external editor (like Bash)"
+            buffer = event.current_buffer
+            current_text = buffer.text
+
+            # Open the editor with the current text
+            edited_text = pipe_editor(input_data=current_text, suffix="md")
+
+            # Replace the buffer with the edited text, strip any trailing newlines
+            buffer.text = edited_text.rstrip("\n")
+
+            # Move cursor to the end of the text
+            buffer.cursor_position = len(buffer.text)
+
+        @kb.add("enter", eager=True, filter=~is_searching & ~has_completions)
+        def _(event):
+            "Handle Enter key press when no completions are shown"
+            if self.io.multiline_mode and not (
+                self.io.editingmode == EditingMode.VI
+                and event.app.vi_state.input_mode == InputMode.NAVIGATION
+            ):
+                # In multiline mode and if not in vi-mode or vi navigation/normal mode,
+                # Enter adds a newline
+                event.current_buffer.insert_text("\n")
+            else:
+                # In normal mode, Enter submits
+                event.current_buffer.validate_and_handle()
+
+        @kb.add("enter", eager=True, filter=~is_searching & has_completions)
+        def _(event):
+            "Handle Enter key press when completions are shown"
+            buffer = event.current_buffer
+            
+            # Check if this is an @ command completion using cursor position (consistent with completer.py)
+            text_before_cursor = buffer.document.text_before_cursor
+            at_pos = text_before_cursor.rfind("@")
+            is_at_command = at_pos != -1
+            
+            if buffer.complete_state and buffer.complete_state.completions:
+                # Ensure first completion is selected by default if none is currently selected
+                if buffer.complete_state.current_completion is None:
+                    # Move to first completion to ensure it's highlighted
+                    buffer.complete_next()
+                
+                # Accept the currently selected completion
+                if buffer.complete_state.current_completion:
+                    buffer.apply_completion(buffer.complete_state.current_completion)
+                    
+                    # For @ commands, only accept completion without submitting
+                    # For other commands (like /), accept completion and submit
+                    if not is_at_command:
+                        # For non-@ commands, also submit after accepting completion
+                        if self.io.multiline_mode and not (
+                            self.io.editingmode == EditingMode.VI
+                            and event.app.vi_state.input_mode == InputMode.NAVIGATION
+                        ):
+                            # In multiline mode, Enter adds a newline after accepting completion
+                            buffer.insert_text("\n")
+                        else:
+                            # In normal mode, Enter submits after accepting completion
+                            buffer.validate_and_handle()
+            else:
+                # No completions available, just handle enter normally
+                if self.io.multiline_mode and not (
+                    self.io.editingmode == EditingMode.VI
+                    and event.app.vi_state.input_mode == InputMode.NAVIGATION
+                ):
+                    # In multiline mode, Enter adds a newline
+                    buffer.insert_text("\n")
+                else:
+                    # In normal mode, Enter submits
+                    buffer.validate_and_handle()
+
+        @kb.add("escape", "enter", eager=True, filter=~is_searching)  # This is Alt+Enter
+        def _(event):
+            "Handle Alt+Enter key press"
+            if self.io.multiline_mode:
+                # In multiline mode, Alt+Enter submits
+                event.current_buffer.validate_and_handle()
+            else:
+                # In normal mode, Alt+Enter adds a newline
+                event.current_buffer.insert_text("\n")
+
+        return kb

siada/io/notification_command.py

@@ -0,0 +1,40 @@
+
+import shutil
+import platform
+
+
+class NotificationCommandUtil:
+    """A utility class for handling notification commands."""
+
+    NOTIFICATION_MESSAGE = "Siada is waiting for your input"
+
+    @staticmethod
+    def get_default_notification_command():
+        """Return a default notification command based on the operating system."""
+        system = platform.system()
+
+        if system == "Darwin":  # macOS
+            # Check for terminal-notifier first
+            if shutil.which("terminal-notifier"):
+                return f"terminal-notifier -title 'Siada' -message '{NotificationCommandUtil.NOTIFICATION_MESSAGE}'"
+            # Fall back to osascript
+            return f'osascript -e \'display notification "{NotificationCommandUtil.NOTIFICATION_MESSAGE}" with title "Siada"\''
+        elif system == "Linux":
+            # Check for common Linux notification tools
+            for cmd in ["notify-send", "zenity"]:
+                if shutil.which(cmd):
+                    if cmd == "notify-send":
+                        return f"notify-send 'Siada' '{NotificationCommandUtil.NOTIFICATION_MESSAGE}'"
+                    elif cmd == "zenity":
+                        return f"zenity --notification --text='{NotificationCommandUtil.NOTIFICATION_MESSAGE}'"
+            return None  # No known notification tool found
+        elif system == "Windows":
+            # PowerShell notification
+            return (
+                "powershell -command"
+                " \"[System.Reflection.Assembly]::LoadWithPartialName('System.Windows.Forms');"
+                f" [System.Windows.Forms.MessageBox]::Show('{NotificationCommandUtil.NOTIFICATION_MESSAGE}',"
+                " 'Siada')\""
+            )
+
+        return None  # Unknown system 

siada/io/test_banner.py

@@ -0,0 +1,64 @@
+#!/usr/bin/env python3
+"""
+Test script for banner display functionality.
+
+Usage:
+    python test_banner.py [--pretty|--plain|--both]
+"""
+
+import argparse
+import sys
+from pathlib import Path
+
+# Add parent directory to path so we can import siada modules
+sys.path.insert(0, str(Path(__file__).parent.parent.parent))
+
+from siada.io.banner import show_siada_banner, get_banner_text
+from rich.console import Console
+
+
+def test_pretty_banner():
+    """Test colorful banner with gradient."""
+    print("=== PRETTY BANNER (Left-to-Right Gradient) ===")
+    show_siada_banner(pretty=True)
+    print()
+
+
+def test_plain_banner():
+    """Test plain text banner."""
+    print("=== PLAIN BANNER ===")
+    show_siada_banner(pretty=False)
+    print()
+
+
+def test_text_banner():
+    """Test banner as string."""
+    print("=== BANNER AS TEXT ===")
+    print(get_banner_text())
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Test SIADA HUB banner display")
+    parser.add_argument("--pretty", action="store_true", help="Show only pretty banner")
+    parser.add_argument("--plain", action="store_true", help="Show only plain banner")
+    parser.add_argument("--both", action="store_true", help="Show both versions")
+    
+    args = parser.parse_args()
+    
+    if args.pretty:
+        test_pretty_banner()
+    elif args.plain:
+        test_plain_banner()
+    elif args.both:
+        test_pretty_banner()
+        test_plain_banner()
+        test_text_banner()
+    else:
+        # Default: show all versions
+        test_pretty_banner()
+        test_plain_banner()
+        test_text_banner()
+
+
+if __name__ == "__main__":
+    main() 

siada/models/agent.py

@@ -0,0 +1,47 @@
+"""
+Agent数据模型
+
+定义与Agent相关的请求和响应模型
+"""
+from typing import Any, Dict, List, Optional
+
+from pydantic import BaseModel, Field
+
+
+class Tool(BaseModel):
+    """工具模型"""
+    name: str = Field(..., description="工具名称")
+    description: str = Field(..., description="工具描述")
+    function: str = Field(..., description="工具函数代码")
+
+
+class CreateAgentRequest(BaseModel):
+    """创建Agent的请求模型"""
+    name: str = Field(..., description="Agent名称")
+    instructions: str = Field(..., description="Agent指令")
+    tools: Optional[List[Tool]] = Field(None, description="Agent可以使用的工具列表")
+
+
+class AgentResponse(BaseModel):
+    """Agent响应模型"""
+    id: str = Field(..., description="Agent ID")
+    name: str = Field(..., description="Agent名称")
+    instructions: str = Field(..., description="Agent指令")
+    model: str = Field(..., description="使用的模型名称")
+
+
+class RunAgentRequest(BaseModel):
+    """运行Agent的请求模型"""
+    agent_name: str = Field(..., description="Agent 名称")
+    input: str = Field(..., description="输入文本")
+    model: Optional[str] = Field("gpt-4o", description="使用的模型名称")
+    max_turns: Optional[int] = Field(10, description="最大运行轮数")
+    session_id: Optional[str] = Field(None, description="会话ID")
+
+
+class RunAgentResponse(BaseModel):
+    """运行Agent的响应模型"""
+    final_output: str = Field(..., description="最终输出")
+    turns: int = Field(..., description="运行轮数")
+    completed: bool = Field(..., description="是否完成")
+    trace_id: Optional[str] = Field(None, description="跟踪ID")

siada/models/converter.py

@@ -0,0 +1,27 @@
+from agents import ModelSettings
+from litellm import Reasoning
+from siada.models.model_base_config import is_gemini_model
+from siada.models.model_run_config import ModelRunConfig
+
+
+class ModelSettingsConverter:
+
+    @staticmethod
+    def convert_model_settings(model_running_config: ModelRunConfig) -> ModelSettings:
+
+        extra_body = {}
+        reasoning = {}
+        if model_running_config.get_reasoning_effort() is not None:
+            reasoning["effort"] = model_running_config.get_reasoning_effort()
+        if model_running_config.get_raw_thinking_tokens() is not None:
+            reasoning["max_tokens"] = model_running_config.get_raw_thinking_tokens()
+
+        if reasoning:
+            extra_body["reasoning"] = reasoning
+
+        model_settings = ModelSettings(
+            max_tokens=model_running_config.max_tokens,
+            extra_body=extra_body,
+        )
+
+        return model_settings

siada/models/model_base_config.py

@@ -0,0 +1,121 @@
+from dataclasses import dataclass
+from typing import Optional, List
+
+@dataclass
+class ModelBaseConfig:
+    """
+    Represents the configuration for a specific language model.
+    """
+    model_name: str
+    context_window: int
+    max_tokens: Optional[int] = None
+    supports_images: bool = False
+    supports_prompt_cache: bool = False
+
+    supports_extra_params: Optional[List[str]] = None
+
+# Simple list of all model configurations
+MODEL_SETTING: List[ModelBaseConfig] = [
+
+    # ModelBaseConfig(
+    #     model_name="o3-pro",
+    #     max_tokens=8192,
+    #     context_window=200_000,
+    #     supports_images=True,
+    #     supports_extra_params=["reasoning_effort"],
+    # ),
+    ModelBaseConfig(
+        model_name="claude-opus-4.1",
+        max_tokens=8192,
+        context_window=200_000,
+        supports_extra_params=[],
+    ),
+
+    ModelBaseConfig(
+        model_name="gpt-5",
+        max_tokens=8192,
+        context_window=400_000,
+        supports_images=True,
+        supports_extra_params=["reasoning_effort"],
+    ),
+
+    ModelBaseConfig(
+        model_name="gpt-5-mini",
+        max_tokens=8192,
+        context_window=400_000,
+        supports_images=True,
+        supports_extra_params=["reasoning_effort"],
+    ),
+
+    ModelBaseConfig(
+        model_name="gpt-4.1",
+        max_tokens=8192,
+        context_window=1_047_576,
+        supports_images=True,
+    ),
+
+    ModelBaseConfig(
+        model_name="claude-opus-4",
+        max_tokens=8192,
+        context_window=200_000,
+        supports_images=True,
+        supports_extra_params=[],
+    ),
+    ModelBaseConfig(
+        model_name="claude-sonnet-4",
+        max_tokens=8192,
+        context_window=200_000,
+        supports_images=True,
+        supports_extra_params=[],
+    ),
+    ModelBaseConfig(
+        model_name="claude-3.7-sonnet",
+        max_tokens=8192,
+        context_window=200_000,
+        supports_images=True,
+        supports_extra_params=[],
+    ),
+
+    ModelBaseConfig(
+        model_name="gemini-2.5-pro",
+        max_tokens=8192,
+        context_window=1_048_576,
+        supports_extra_params=["thinking_tokens"],
+    ),
+
+    ModelBaseConfig(
+        model_name="deepseek-v3-0324",
+        max_tokens=8192,
+        context_window=128_000,
+    ),
+
+    ModelBaseConfig(
+        model_name="kimi-k2",
+        max_tokens=8192,
+        context_window=131_072,
+    ),
+]
+
+def is_gemini_model(model_name: str) -> bool:
+    return model_name.startswith("gemini-")
+
+def get_model_config(model_name: str) -> Optional[ModelBaseConfig]:
+    """
+    Retrieves the configuration for a given model name.
+    
+    Args:
+        model_name: The name of the model to retrieve.
+        
+    Returns:
+        A ModelSettings instance if the model is found, otherwise None.
+    """
+    # Check if model_name is None or empty
+    if not model_name:
+        raise ValueError("Model name cannot be None or empty")
+        
+    # Only exact match
+    for model_config in MODEL_SETTING:
+        if model_config.model_name == model_name:
+            return model_config
+            
+    return None

siada/models/model_run_config.py

@@ -0,0 +1,153 @@
+from dataclasses import dataclass, fields
+from typing import Optional
+
+from siada.models.model_base_config import ModelBaseConfig, get_model_config
+
+import os
+from pathlib import Path
+
+import logging
+import yaml
+@dataclass()
+class ModelRunConfig(ModelBaseConfig):
+    
+    reasoning_effort : Optional[str] = None
+    thinking_tokens : Optional[int] = None
+    temperature : Optional[float] = None
+    extra_params : Optional[dict] = None
+    provider: Optional[str] = None
+
+
+
+    def __init__(self, model): 
+        self.configure_model_settings(model)
+
+
+    def _copy_fields(self, source):
+        """Helper to copy fields from a ModelSettings instance to self"""
+        for field in fields(ModelBaseConfig):
+            val = getattr(source, field.name)
+            setattr(self, field.name, val)
+
+
+    def configure_model_settings(self, model):
+        # Look for exact model match
+        model_config = get_model_config(model)
+        if model_config:
+            self._copy_fields(model_config)
+        else:
+            raise ValueError(f"Model {model} not found in model settings")
+        
+
+    def set_reasoning_effort(self, reasoning_effort):
+        self.reasoning_effort = reasoning_effort
+
+
+    def get_raw_thinking_tokens(self):
+        """Get formatted thinking token budget if available"""
+        return self.thinking_tokens
+
+    def get_thinking_tokens(self):
+        budget = self.get_raw_thinking_tokens()
+
+        if budget is not None:
+            # Format as xx.yK for thousands, xx.yM for millions
+            if budget >= 1024 * 1024:
+                value = budget / (1024 * 1024)
+                if value == int(value):
+                    return f"{int(value)}M"
+                else:
+                    return f"{value:.1f}M"
+            else:
+                value = budget / 1024
+                if value == int(value):
+                    return f"{int(value)}k"
+                else:
+                    return f"{value:.1f}k"
+        return None
+    
+    def get_reasoning_effort(self):
+        """Get reasoning effort value if available"""
+        return self.reasoning_effort
+    
+
+    def set_reasoning_effort(self, effort):
+        """Set the reasoning effort parameter for models that support it"""
+        if effort is not None:
+            self.reasoning_effort = effort
+    
+
+    def set_thinking_tokens(self, value):
+        """
+        Set the thinking token budget for models that support it.
+        Accepts formats: 8096, "8k", "10.5k", "0.5M", "10K", etc.
+        Pass "0" to disable thinking tokens.
+        """
+        if value is not None:
+            num_tokens = self.parse_token_value(value)
+            self.temperature = None
+            if num_tokens > 0:
+                self.thinking_tokens = num_tokens
+            else:
+                self.thinking_tokens = None
+
+
+    def parse_token_value(self, value):
+        """
+        Parse a token value string into an integer.
+        Accepts formats: 8096, "8k", "10.5k", "0.5M", "10K", etc.
+
+        Args:
+            value: String or int token value
+
+        Returns:
+            Integer token value
+        """
+        if isinstance(value, int):
+            return value
+
+        if not isinstance(value, str):
+            return int(value)  # Try to convert to int
+
+        value = value.strip().upper()
+
+        if value.endswith("K"):
+            multiplier = 1024
+            value = value[:-1]
+        elif value.endswith("M"):
+            multiplier = 1024 * 1024
+            value = value[:-1]
+        else:
+            multiplier = 1
+
+        # Convert to float first to handle decimal values like "10.5k"
+        return int(float(value) * multiplier)
+    
+
+    @staticmethod
+    def get_default_config():
+        project_root = Path(__file__).parent.parent.parent
+        config_path = project_root / "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)}")
+        model_name = llm_config.get('model_name')
+        provider = llm_config.get('provider')
+
+        model_config = ModelRunConfig(model_name)
+
+        model_config.provider = provider
+        return model_config
+
+
+
+
+
+
+
+