siada-cli 0.0.1__py3-none-any.whl

siada/services/handle_at_command/utils.py

@@ -0,0 +1,345 @@
+"""
+Utility functions for HandleAtCommand functionality.
+"""
+
+import os
+import re
+from pathlib import Path
+from typing import List, Dict, Optional, Any, Tuple
+
+
+def normalize_path(path: str) -> str:
+    """
+    Normalize a file path for consistent handling
+    
+    Args:
+        path: File path to normalize
+        
+    Returns:
+        Normalized path string
+    """
+    if not path:
+        return path
+    
+    # Convert to Path object and resolve
+    normalized = Path(path).as_posix()
+    
+    # Remove leading './' if present
+    if normalized.startswith('./'):
+        normalized = normalized[2:]
+    
+    return normalized
+
+
+def is_text_file(file_path: str) -> bool:
+    """
+    Check if a file is likely a text file based on extension
+    
+    Args:
+        file_path: Path to the file
+        
+    Returns:
+        True if likely a text file, False otherwise
+    """
+    text_extensions = {
+        '.py', '.js', '.ts', '.jsx', '.tsx', '.java', '.c', '.cpp', '.cc', '.cxx',
+        '.h', '.hpp', '.cs', '.php', '.rb', '.go', '.rs', '.swift', '.kt', '.scala',
+        '.clj', '.hs', '.ml', '.fs', '.vb', '.pl', '.sh', '.bash', '.zsh', '.fish',
+        '.ps1', '.bat', '.cmd', '.html', '.htm', '.xml', '.css', '.scss', '.sass',
+        '.less', '.json', '.yaml', '.yml', '.toml', '.ini', '.cfg', '.conf',
+        '.properties', '.env', '.md', '.rst', '.txt', '.log', '.sql', '.r',
+        '.m', '.mm', '.dart', '.lua', '.vim', '.dockerfile', '.makefile',
+        '.cmake', '.gradle', '.maven', '.ant', '.sbt', '.cabal', '.nix'
+    }
+    
+    file_ext = Path(file_path).suffix.lower()
+    return file_ext in text_extensions
+
+
+def is_image_file(file_path: str) -> bool:
+    """
+    Check if a file is an image based on extension
+    
+    Args:
+        file_path: Path to the file
+        
+    Returns:
+        True if an image file, False otherwise
+    """
+    image_extensions = {
+        '.png', '.jpg', '.jpeg', '.gif', '.bmp', '.webp', '.svg', '.ico',
+        '.tiff', '.tif', '.psd', '.ai', '.eps'
+    }
+    
+    file_ext = Path(file_path).suffix.lower()
+    return file_ext in image_extensions
+
+
+def is_pdf_file(file_path: str) -> bool:
+    """
+    Check if a file is a PDF
+    
+    Args:
+        file_path: Path to the file
+        
+    Returns:
+        True if a PDF file, False otherwise
+    """
+    return Path(file_path).suffix.lower() == '.pdf'
+
+
+def sanitize_path_for_display(path: str) -> str:
+    """
+    Sanitize a path for safe display in messages
+    
+    Args:
+        path: Path to sanitize
+        
+    Returns:
+        Sanitized path string
+    """
+    if not path:
+        return path
+    
+    # Remove any potential control characters
+    sanitized = re.sub(r'[\x00-\x1f\x7f-\x9f]', '', path)
+    
+    # Limit length for display
+    max_length = 100
+    if len(sanitized) > max_length:
+        sanitized = sanitized[:max_length] + '...'
+    
+    return sanitized
+
+
+def format_file_size(size_bytes: int) -> str:
+    """
+    Format file size in human-readable format
+    
+    Args:
+        size_bytes: Size in bytes
+        
+    Returns:
+        Formatted size string
+    """
+    if size_bytes == 0:
+        return "0 B"
+    
+    size_names = ["B", "KB", "MB", "GB", "TB"]
+    i = 0
+    size = float(size_bytes)
+    
+    while size >= 1024.0 and i < len(size_names) - 1:
+        size /= 1024.0
+        i += 1
+    
+    return f"{size:.1f} {size_names[i]}"
+
+
+def extract_filename_from_path(path: str) -> str:
+    """
+    Extract filename from a path
+    
+    Args:
+        path: File path
+        
+    Returns:
+        Filename without directory
+    """
+    return Path(path).name
+
+
+def get_file_extension(path: str) -> str:
+    """
+    Get file extension from path
+    
+    Args:
+        path: File path
+        
+    Returns:
+        File extension (including dot)
+    """
+    return Path(path).suffix
+
+
+def is_hidden_file(path: str) -> bool:
+    """
+    Check if a file or directory is hidden (starts with dot)
+    
+    Args:
+        path: File path
+        
+    Returns:
+        True if hidden, False otherwise
+    """
+    filename = Path(path).name
+    return filename.startswith('.')
+
+
+def split_path_components(path: str) -> List[str]:
+    """
+    Split path into components
+    
+    Args:
+        path: File path
+        
+    Returns:
+        List of path components
+    """
+    return Path(path).parts
+
+
+def join_path_components(components: List[str]) -> str:
+    """
+    Join path components into a path
+    
+    Args:
+        components: List of path components
+        
+    Returns:
+        Joined path string
+    """
+    if not components:
+        return ""
+    
+    return str(Path(*components))
+
+
+def validate_filename(filename: str) -> bool:
+    """
+    Validate that a filename is safe and valid
+    
+    Args:
+        filename: Filename to validate
+        
+    Returns:
+        True if valid, False otherwise
+    """
+    if not filename:
+        return False
+    
+    # Check for invalid characters
+    invalid_chars = ['<', '>', ':', '"', '|', '?', '*', '\0']
+    for char in invalid_chars:
+        if char in filename:
+            return False
+    
+    # Check for reserved names (Windows)
+    reserved_names = {
+        'CON', 'PRN', 'AUX', 'NUL',
+        'COM1', 'COM2', 'COM3', 'COM4', 'COM5', 'COM6', 'COM7', 'COM8', 'COM9',
+        'LPT1', 'LPT2', 'LPT3', 'LPT4', 'LPT5', 'LPT6', 'LPT7', 'LPT8', 'LPT9'
+    }
+    
+    name_without_ext = Path(filename).stem.upper()
+    if name_without_ext in reserved_names:
+        return False
+    
+    # Check length
+    if len(filename) > 255:
+        return False
+    
+    return True
+
+
+def create_safe_filename(original: str) -> str:
+    """
+    Create a safe filename from an original string
+    
+    Args:
+        original: Original filename
+        
+    Returns:
+        Safe filename
+    """
+    if not original:
+        return "unnamed"
+    
+    # Replace invalid characters with underscores
+    safe = re.sub(r'[<>:"|?*\0]', '_', original)
+    
+    # Remove leading/trailing dots and spaces
+    safe = safe.strip('. ')
+    
+    # Ensure it's not empty
+    if not safe:
+        safe = "unnamed"
+    
+    # Truncate if too long
+    if len(safe) > 255:
+        name, ext = os.path.splitext(safe)
+        max_name_len = 255 - len(ext)
+        safe = name[:max_name_len] + ext
+    
+    return safe
+
+
+def format_processing_time(seconds: float) -> str:
+    """
+    Format processing time in human-readable format
+    
+    Args:
+        seconds: Time in seconds
+        
+    Returns:
+        Formatted time string
+    """
+    if seconds < 1:
+        return f"{seconds * 1000:.0f}ms"
+    elif seconds < 60:
+        return f"{seconds:.1f}s"
+    else:
+        minutes = int(seconds // 60)
+        remaining_seconds = seconds % 60
+        return f"{minutes}m {remaining_seconds:.1f}s"
+
+
+def truncate_content(content: str, max_length: int = 1000) -> Tuple[str, bool]:
+    """
+    Truncate content if it's too long
+    
+    Args:
+        content: Content to truncate
+        max_length: Maximum length allowed
+        
+    Returns:
+        Tuple of (truncated_content, was_truncated)
+    """
+    if len(content) <= max_length:
+        return content, False
+    
+    truncated = content[:max_length] + "... [content truncated]"
+    return truncated, True
+
+
+def count_lines(content: str) -> int:
+    """
+    Count number of lines in content
+    
+    Args:
+        content: Content to count lines in
+        
+    Returns:
+        Number of lines
+    """
+    if not content:
+        return 0
+    
+    return len(content.splitlines())
+
+
+def estimate_tokens(content: str) -> int:
+    """
+    Estimate number of tokens in content (rough approximation)
+    
+    Args:
+        content: Content to estimate tokens for
+        
+    Returns:
+        Estimated token count
+    """
+    if not content:
+        return 0
+    
+    # Rough approximation: 1 token ≈ 4 characters
+    return len(content) // 4

siada/services/model_info_service.py

@@ -0,0 +1,103 @@
+"""
+Model Information Service
+
+Provides comprehensive model information, validation, and management capabilities.
+This service acts as a centralized interface for model-related operations.
+"""
+
+from typing import List, Optional, Dict, Any
+from dataclasses import asdict
+
+from siada.models.model_base_config import ModelBaseConfig, MODEL_SETTING, get_model_config
+from siada.models.model_run_config import ModelRunConfig
+
+
+class ModelInfoService:
+    """
+    Service for managing and querying model information.
+    
+    This service provides methods to:
+    - List available models
+    - Get detailed model information
+    - Validate model configurations
+    - Search and filter models by capabilities
+    """
+
+    @staticmethod
+    def get_all_models() -> List[ModelBaseConfig]:
+        """
+        Get all available model configurations.
+        
+        Returns:
+            List[ModelBaseConfig]: List of all model configurations
+        """
+        return MODEL_SETTING.copy()
+
+    @staticmethod
+    def get_model_names() -> List[str]:
+        """
+        Get a list of all available model names.
+        
+        Returns:
+            List[str]: List of model names
+        """
+        return [model.model_name for model in MODEL_SETTING]
+
+    @staticmethod
+    def get_model_info(model_name: str) -> Optional[ModelBaseConfig]:
+        """
+        Get detailed information for a specific model.
+        
+        Args:
+            model_name: Name of the model to query
+            
+        Returns:
+            Optional[ModelBaseConfig]: Model configuration if found, None otherwise
+        """
+        return get_model_config(model_name)
+
+    @staticmethod
+    def is_model_supported(model_name: str) -> bool:
+        """
+        Check if a model is supported.
+        
+        Args:
+            model_name: Name of the model to check
+            
+        Returns:
+            bool: True if model is supported, False otherwise
+        """
+        return get_model_config(model_name) is not None
+
+    @staticmethod
+    def get_models_with_images() -> List[ModelBaseConfig]:
+        """
+        Get all models that support image processing.
+        
+        Returns:
+            List[ModelBaseConfig]: List of models with image support
+        """
+        return [model for model in MODEL_SETTING if model.supports_images]
+
+    @staticmethod
+    def search_models(query: str, case_sensitive: bool = False) -> List[ModelBaseConfig]:
+        """
+        Search for models by name.
+        
+        Args:
+            query: Search query string
+            case_sensitive: Whether to perform case-sensitive search (default: False)
+            
+        Returns:
+            List[ModelBaseConfig]: List of models matching the search query
+        """
+        if not case_sensitive:
+            query = query.lower()
+        
+        results = []
+        for model in MODEL_SETTING:
+            model_name = model.model_name if case_sensitive else model.model_name.lower()
+            if query in model_name:
+                results.append(model)
+        
+        return results

siada/services/siada_runner.py

@@ -0,0 +1,170 @@
+import asyncio
+import importlib
+import os
+from pathlib import Path
+from siada.session.session_models import RunningSession
+from typing import Dict, Type, Optional, Union, Literal, overload
+
+import yaml
+from agents import RunResult, RunResultStreaming, Agent, set_trace_processors
+
+from siada.agent_hub.coder.tracing import create_detailed_logger
+from siada.agent_hub.siada_agent import SiadaAgent
+
+import logging
+
+from siada.services.code_context_manager import ContextTracingProcessor
+
+class SiadaRunner:
+
+    @overload
+    @staticmethod
+    async def run_agent(
+        agent_name: str,
+        user_input: str,
+        workspace: str = None,
+        session: RunningSession = None,
+        *,
+        stream: Literal[True],
+    ) -> RunResultStreaming: ...
+
+    @overload
+    @staticmethod
+    async def run_agent(
+        agent_name: str,
+        user_input: str,
+        workspace: str = None,
+        session: RunningSession = None,
+        *,
+        stream: Literal[False],
+    ) -> RunResult: ...
+
+    @staticmethod
+    async def run_agent(
+        agent_name: str,
+        user_input: str,
+        workspace: str = None,
+        session: RunningSession = None,
+        stream: bool = False,
+    ) -> RunResult | RunResultStreaming:
+        """
+        Run the specified Agent.
+
+        Args:
+            agent_name: Name of the Agent.
+            user_input: User input.
+            workspace: Workspace path, optional.
+            session: The running session object, optional.
+            stream: Whether to enable streaming output, defaults to False.
+
+        Returns:
+            Union[RunResult, RunResultStreaming]: Returns a regular or streaming result based on the stream parameter.
+        """
+        agent = await SiadaRunner.get_agent(agent_name)
+        context = await agent.get_context()
+        console_output = False
+        if workspace:
+            context.root_dir = workspace
+        if session:
+            context.session = session
+
+        # set_trace_processors([create_detailed_logger(output_file="agent_trace.log")])
+        console_output = session.siada_config.console_output if session else True
+        context_tracing_processor = ContextTracingProcessor(context)
+
+        set_trace_processors([create_detailed_logger(console_output=console_output),
+                              context_tracing_processor])
+
+        if stream:
+            # Stream execution
+            result = await agent.run_streamed(user_input, context)
+        else:
+            # Normal execution
+            result = await agent.run(user_input, context)
+
+        return result
+
+    @staticmethod
+    async def get_agent(agent_name: str) -> SiadaAgent:
+        """
+        Get the corresponding Agent instance based on agent name
+        
+        Args:
+            agent_name: Agent name, supports case-insensitive matching
+                       e.g.: 'bugfix', 'BugFix', 'bug_fix', etc.
+        
+        Returns:
+            Agent: The corresponding Agent instance
+            
+        Raises:
+            ValueError: Raised when the corresponding Agent type is not found
+            FileNotFoundError: Raised when the configuration file does not exist
+            ImportError: Raised when unable to import Agent class
+        """
+        # Normalize agent name: convert to lowercase and remove underscores and hyphens
+        normalized_name = agent_name.lower().replace('_', '').replace('-', '')
+
+        # Load Agent mapping from configuration file
+        agent_configs = SiadaRunner._load_agent_config()
+
+        # Find the corresponding Agent configuration
+        agent_config = agent_configs.get(normalized_name)
+
+        if agent_config is None:
+            supported_agents = [name for name, config in agent_configs.items() 
+                              if config.get('enabled', False) and config.get('class')]
+            raise ValueError(
+                f"Unsupported agent type: '{agent_name}'. "
+                f"Supported agent types: {supported_agents}"
+            )
+
+        # Check if Agent is enabled
+        if not agent_config.get('enabled', False):
+            raise ValueError(f"Agent '{agent_name}' is disabled")
+
+        # Check if Agent class is implemented
+        class_path = agent_config.get('class')
+        if not class_path:
+            raise ValueError(f"Agent '{agent_name}' is not implemented yet")
+
+        # Dynamically import and instantiate Agent class
+        try:
+            agent_class = SiadaRunner._import_agent_class(class_path)
+            return agent_class()
+        except (ImportError, AttributeError) as e:
+            raise ImportError(f"Failed to import agent class '{class_path}': {e}")
+
+    @staticmethod
+    def _load_agent_config() -> Dict[str, Dict]:
+        """
+        Load Agent configuration from configuration file
+
+        Returns:
+            Dict[str, Dict]: Agent configuration dictionary
+        """
+        # Get the configuration file path in the project root directory
+        current_dir = Path(__file__).parent.parent.parent  # Go back to project root directory
+        config_path = current_dir / "agent_config.yaml"
+
+        if not config_path.exists():
+            raise FileNotFoundError(f"Agent configuration file not found: {config_path}")
+
+        with open(config_path, 'r', encoding='utf-8') as f:
+            config = yaml.safe_load(f)
+
+        return config.get('agents', {})
+
+    @staticmethod
+    def _import_agent_class(class_path: str) -> Type[Agent]:
+        """
+        Dynamically import Agent class
+
+        Args:
+            class_path: Complete import path of Agent class, e.g. 'siada.agent_hub.coder.bug_fix_agent.BugFixAgent'
+
+        Returns:
+            Type[Agent]: Agent class
+        """
+        module_path, class_name = class_path.rsplit('.', 1)
+        module = importlib.import_module(module_path)
+        return getattr(module, class_name)

siada/session/__init__.py

@@ -0,0 +1,29 @@
+"""
+Interaction Session Management Module
+
+Provides interaction session management functionality working with OpenAI Agents SQLiteSession:
+
+Core Features:
+- Create interaction sessions and associated OpenAI SQLiteSession
+- Interaction session and openai_session share the same ID
+- Support ModelSettings model configuration
+- Simplified API focusing on session creation
+"""
+
+from .session_models import (
+    RunningSession,
+    SessionState
+)
+
+from .session_manager import (
+    RunningSessionManager,
+)
+
+__all__ = [
+    # Data models
+    "RunningSession",
+    "SessionState",
+    
+    # Managers
+    "RunningSessionManager",
+]

siada/session/session_manager.py

@@ -0,0 +1,66 @@
+from typing import Optional
+import logging
+from uuid import uuid4
+
+from siada.entrypoint.interaction.config import RunningConfig
+from siada.io.io import InputOutput
+from siada.models.model_run_config import ModelRunConfig
+from siada.support.slash_commands import SlashCommands
+
+from .session_models import RunningSession, SessionState
+from siada.models.model_base_config import ModelBaseConfig
+
+logger = logging.getLogger(__name__)
+
+
+class RunningSessionManager:
+    
+    @staticmethod
+    def create_session(
+        siada_config: RunningConfig,
+        session_id: Optional[str] = None,
+    ) -> RunningSession:
+        """
+        Create a new interaction session
+        
+        Args:
+            siada_config: config of siada running
+            session_id: Session ID, auto-generates UUID if not provided
+
+        Returns:
+            Session: Created session object
+        """
+        # Use provided session_id or generate new UUID
+        if session_id is None:
+            session_id = str(uuid4())
+        
+        # Create interaction session
+        session = RunningSession(
+            session_id=session_id,
+            siada_config=siada_config,
+        )
+        
+        # Create associated OpenAI SQLiteSession with same ID
+        from agents import SQLiteSession
+        
+        # Create OpenAI Session
+        openai_session = SQLiteSession(
+            session_id=session_id,  # Use same ID
+        )
+        session.state.openai_session = openai_session
+        return session
+
+    @staticmethod
+    def get_default_session():
+        llm_config = ModelRunConfig.get_default_config()
+        io = InputOutput()
+
+        siada_config = RunningConfig(
+            llm_config=llm_config,
+            io=io,
+            workspace='',
+            agent_name='',
+            console_output=True,
+            interactive=False,
+        )
+        return RunningSessionManager.create_session(siada_config)