siada-cli 0.0.1__py3-none-any.whl

siada/tools/tool_call_format/file_to_language.py

@@ -0,0 +1,231 @@
+import os
+from typing import Optional
+
+
+def get_language_from_file_extension(filename: str) -> str:
+    """
+    Get the language identifier for markdown code fences based on file extension.
+    
+    Args:
+        filename: The name of the file (can include path)
+        
+    Returns:
+        Language identifier string for markdown code fences
+    """
+    if not filename:
+        return ""
+    
+    # Extract the file extension (convert to lowercase for case-insensitive matching)
+    _, ext = os.path.splitext(filename.lower())
+    
+    # Remove the leading dot
+    ext = ext.lstrip('.')
+    
+    # Mapping of file extensions to language identifiers
+    extension_to_language = {
+        # Python
+        'py': 'python',
+        'pyw': 'python',
+        'pyi': 'python',
+        
+        # JavaScript/TypeScript
+        'js': 'javascript',
+        'mjs': 'javascript',
+        'jsx': 'jsx',
+        'ts': 'typescript',
+        'tsx': 'tsx',
+        
+        # Java/JVM languages
+        'java': 'java',
+        'kt': 'kotlin',
+        'kts': 'kotlin',
+        'scala': 'scala',
+        'sc': 'scala',
+        'groovy': 'groovy',
+        'gradle': 'gradle',
+        
+        # C/C++
+        'c': 'c',
+        'h': 'c',
+        'cpp': 'cpp',
+        'cxx': 'cpp',
+        'cc': 'cpp',
+        'c++': 'cpp',
+        'hpp': 'cpp',
+        'hxx': 'cpp',
+        'hh': 'cpp',
+        
+        # C#
+        'cs': 'csharp',
+        
+        # Go
+        'go': 'go',
+        
+        # Rust
+        'rs': 'rust',
+        
+        # PHP
+        'php': 'php',
+        'php3': 'php',
+        'php4': 'php',
+        'php5': 'php',
+        'phtml': 'php',
+        
+        # Ruby
+        'rb': 'ruby',
+        'rbw': 'ruby',
+        'rake': 'ruby',
+        'gemspec': 'ruby',
+        
+        # Swift
+        'swift': 'swift',
+        
+        # Objective-C
+        'm': 'objective-c',
+        'mm': 'objective-c',
+        
+        # Dart
+        'dart': 'dart',
+        
+        # R
+        'r': 'r',
+        
+        # Shell scripting
+        'sh': 'bash',
+        'bash': 'bash',
+        'zsh': 'zsh',
+        'fish': 'fish',
+        'csh': 'csh',
+        'tcsh': 'tcsh',
+        
+        # PowerShell
+        'ps1': 'powershell',
+        'psm1': 'powershell',
+        'psd1': 'powershell',
+        
+        # SQL
+        'sql': 'sql',
+        'mysql': 'sql',
+        'pgsql': 'sql',
+        'plsql': 'sql',
+        
+        # Web technologies
+        'html': 'html',
+        'htm': 'html',
+        'xhtml': 'html',
+        'css': 'css',
+        'scss': 'scss',
+        'sass': 'sass',
+        'less': 'less',
+        'styl': 'stylus',
+        
+        # Markup and data formats
+        'xml': 'xml',
+        'xsl': 'xml',
+        'xslt': 'xml',
+        'svg': 'xml',
+        'json': 'json',
+        'yaml': 'yaml',
+        'yml': 'yaml',
+        'toml': 'toml',
+        'ini': 'ini',
+        'cfg': 'ini',
+        'conf': 'ini',
+        'properties': 'properties',
+        
+        # Documentation
+        'md': 'markdown',
+        'markdown': 'markdown',
+        'mdown': 'markdown',
+        'mkd': 'markdown',
+        'rst': 'rst',
+        'tex': 'latex',
+        'latex': 'latex',
+        
+        # Docker
+        'dockerfile': 'dockerfile',
+        
+        # Other scripting languages
+        'lua': 'lua',
+        'pl': 'perl',
+        'pm': 'perl',
+        'py': 'python',
+        'vim': 'vim',
+        'vimrc': 'vim',
+        
+        # Functional languages
+        'hs': 'haskell',
+        'lhs': 'haskell',
+        'elm': 'elm',
+        'ml': 'ocaml',
+        'mli': 'ocaml',
+        'fs': 'fsharp',
+        'fsi': 'fsharp',
+        'fsx': 'fsharp',
+        'clj': 'clojure',
+        'cljs': 'clojure',
+        'cljc': 'clojure',
+        'edn': 'clojure',
+        
+        # Assembly
+        'asm': 'assembly',
+        's': 'assembly',
+        
+        # Other formats
+        'cmake': 'cmake',
+        'make': 'makefile',
+        'makefile': 'makefile',
+        'dockerfile': 'dockerfile',
+        'gitignore': 'gitignore',
+        'gitconfig': 'gitconfig',
+        'editorconfig': 'editorconfig',
+    }
+    
+    # Return the mapped language or the extension itself if not found
+    return extension_to_language.get(ext, ext if ext else "text")
+
+
+def get_language_from_filename(filename: str) -> str:
+    """
+    Alias for get_language_from_file_extension for backward compatibility.
+    
+    Args:
+        filename: The name of the file (can include path)
+        
+    Returns:
+        Language identifier string for markdown code fences
+    """
+    return get_language_from_file_extension(filename)
+
+
+def is_supported_language(filename: str) -> bool:
+    """
+    Check if the file extension is supported (has a known language mapping).
+    
+    Args:
+        filename: The name of the file (can include path)
+        
+    Returns:
+        True if the language is explicitly supported, False otherwise
+    """
+    if not filename:
+        return False
+    
+    _, ext = os.path.splitext(filename.lower())
+    ext = ext.lstrip('.')
+    
+    supported_extensions = {
+        'py', 'pyw', 'pyi', 'js', 'mjs', 'jsx', 'ts', 'tsx', 'java', 'kt', 'kts',
+        'scala', 'sc', 'groovy', 'gradle', 'c', 'h', 'cpp', 'cxx', 'cc', 'c++',
+        'hpp', 'hxx', 'hh', 'cs', 'go', 'rs', 'php', 'php3', 'php4', 'php5',
+        'phtml', 'rb', 'rbw', 'rake', 'gemspec', 'swift', 'm', 'mm', 'dart', 'r',
+        'sh', 'bash', 'zsh', 'fish', 'csh', 'tcsh', 'ps1', 'psm1', 'psd1', 'sql',
+        'mysql', 'pgsql', 'plsql', 'html', 'htm', 'xhtml', 'css', 'scss', 'sass',
+        'less', 'styl', 'xml', 'xsl', 'xslt', 'svg', 'json', 'yaml', 'yml', 'toml',
+        'ini', 'cfg', 'conf', 'properties', 'md', 'markdown', 'mdown', 'mkd', 'rst',
+        'tex', 'latex', 'dockerfile', 'lua', 'pl', 'pm', 'vim', 'vimrc', 'hs', 'lhs',
+        'elm', 'ml', 'mli', 'fs', 'fsi', 'fsx', 'clj', 'cljs', 'cljc', 'edn', 'asm',
+        's', 'cmake', 'make', 'makefile', 'gitignore', 'gitconfig', 'editorconfig'
+    }
+    
+    return ext in supported_extensions

siada/tools/tool_call_format/formatter_factory.py

@@ -0,0 +1,80 @@
+from typing import Dict, Optional, Type
+
+from siada.tools.tool_call_format.formatters import DefaultFormatter
+from .tool_call_formatter import ToolCallFormatter
+
+
+class ToolCallFormatterFactory:
+    """
+    Tool call formatter 工厂类
+    根据函数名创建相应的formatter实例
+    """
+
+    _formatters: Dict[str, Type[ToolCallFormatter]] = {}
+    _instances: Dict[str, ToolCallFormatter] = {}
+
+    @classmethod
+    def register_formatter(cls, formatter_class: Type[ToolCallFormatter]) -> None:
+        """
+        注册一个formatter类
+        
+        Args:
+            formatter_class: Formatter类
+        """
+        instance = formatter_class()
+        cls._formatters[instance.supported_function] = formatter_class
+            
+    @classmethod
+    def get_formatter(cls, function_name: str) -> Optional[ToolCallFormatter]:
+        """
+        根据函数名获取相应的formatter实例
+        
+        Args:
+            function_name: 函数名称
+            
+        Returns:
+            对应的formatter实例，如果不存在则返回None
+        """
+        if function_name not in cls._formatters:
+            return DefaultFormatter()
+            
+        if function_name not in cls._instances:
+            formatter_class = cls._formatters[function_name]
+            cls._instances[function_name] = formatter_class()
+            
+        return cls._instances[function_name]
+
+    @classmethod
+    def create_formatter(cls, function_name: str) -> Optional[ToolCallFormatter]:
+        """
+        创建formatter实例（每次都创建新实例）
+        
+        Args:
+            function_name: 函数名称
+            
+        Returns:
+            新的formatter实例，如果不存在则返回None
+        """
+        if function_name not in cls._formatters:
+            return None
+            
+        formatter_class = cls._formatters[function_name]
+        return formatter_class()
+
+    @classmethod
+    def list_supported_functions(cls) -> list[str]:
+        """
+        列出所有支持的函数名
+        
+        Returns:
+            支持的函数名列表
+        """
+        return list(cls._formatters.keys())
+
+    @classmethod
+    def clear_registry(cls) -> None:
+        """
+        清空注册的formatter（主要用于测试）
+        """
+        cls._formatters.clear()
+        cls._instances.clear() 

siada/tools/tool_call_format/formatters.py

@@ -0,0 +1,282 @@
+import json
+import os
+from typing import Tuple
+from siada.tools.coder.files import resolve_path
+from siada.tools.tool_call_format.tool_call_formatter import ToolCallFormatter
+
+
+from partial_json_parser import loads, MalformedJSON, ensure_json
+
+
+class DefaultFormatter(ToolCallFormatter):
+
+
+    def format_input(self, call_id: str, function_name: str, arguments: str) -> Tuple[str, bool]:
+        return arguments, True
+
+    @property
+    def supported_function(self) -> str:
+        return "default"
+
+
+class FileEditFormatter(ToolCallFormatter):
+    """
+    File operation formatter
+    """
+
+    def format_input(
+        self, call_id: str, function_name: str, arguments: str
+    ) -> Tuple[str, str, bool]:
+
+        # Valid command enumeration
+        VALID_COMMANDS = {"view", "create", "str_replace", "insert", "undo_edit"}
+        complete = False
+        content = ""
+        try:
+            # Use partial JSON parser to handle incomplete arguments
+            args = loads(arguments)
+            if arguments == ensure_json(arguments):
+                complete = True
+
+            # Safely extract values, handling potential None/missing keys
+            path = args.get("path", None) if args else ""
+            raw_command = args.get("command", None) if args else ""
+            file_text = args.get("file_text", None) if args else ""
+            old_str = args.get("old_str", None) if args else ""
+            new_str = args.get("new_str", None) if args else ""
+            view_range = args.get("view_range", None) if args else None
+            insert_line = args.get("insert_line", None) if args else None
+
+            # Validate command - only return valid commands, otherwise empty string
+            command = raw_command if raw_command in VALID_COMMANDS else ""
+
+            # If command is not valid, return empty string regardless of other parameters
+            if not command:
+                return "", False
+            
+            # if path is a valid path, get the fence
+            fence = ""
+            if path:
+                from .file_to_language import get_language_from_file_extension
+                fence = get_language_from_file_extension(path)
+
+            if command == "view":
+                if complete:
+                    if path:
+                        # Safely check if path has file extension
+                        try:
+                            is_file = bool(os.path.splitext(str(path))[1])  # Has extension = likely a file
+                        except Exception:
+                            is_file = False  # Default to directory if path is invalid
+                        if is_file:
+                            content = f"I will read the file `{path}"
+                            if view_range and len(view_range) == 2:
+                                content += f"` from line {view_range[0]} to line {view_range[1]}."
+                        else:
+                            content = f"I will view the directory `{path}`."
+            elif command == "create":
+
+                if path:
+                    content = f"I will create the file `{path}"
+                    if file_text and complete:
+                        content += f"` with the following content:\n```{fence}\n{file_text}\n```"
+            elif command == "str_replace":
+                if path:
+                    content = f"In the file `{path}"
+                    if old_str is not None:
+                        if new_str is not None:
+                            content += f"`, I will replace the string:\n```{fence}\n{old_str}\n```"
+                            if complete:
+                                content += f"\nwith:\n```{fence}\n{new_str}\n```"
+            elif command == "insert":
+
+                if path:
+                    content = f"In the file `{path}"
+                    if insert_line is not None and new_str and complete:
+                        content += f"`, I will insert the following text after line {insert_line}:\n```{fence}\n{new_str}\n```"
+            elif command == "undo_edit":
+                if path:
+                    content = f"I will undo the last edit for the file `{path}"
+                    if complete:
+                        content += "`"
+            else:
+                # If command is not valid or empty, return empty content
+                content = ""
+
+            return content, complete
+        except Exception as e:
+            # Handle any parsing errors gracefully
+            return content + f"failed to parse arguments: {arguments}", False
+
+    def supports_streaming(self) -> bool:
+        """FileEditFormatter supports streaming rendering"""
+        return True
+
+    @property
+    def supported_function(self) -> str:
+        return "edit_file"
+    
+
+    def get_style(self) -> str:
+        return "markdown"
+
+
+class SearchFormatter(ToolCallFormatter):
+    """
+    Search formatter
+    """
+
+    def format_input(self, call_id: str, function_name: str, arguments: str) -> Tuple[str, bool]:
+        try:
+            args = json.loads(arguments)
+            cwd = args.get("cwd", os.getcwd())
+            directory_path = args.get("directory_path", "")
+            regex = args.get("regex", "")
+            file_pattern = args.get("file_pattern", "*")
+            content = f"I will search for: {regex} in {directory_path} with file pattern {file_pattern} in {cwd}"
+            return content, True
+        except json.JSONDecodeError:
+            return f"failed to parse arguments: {arguments}", False
+
+    @property
+    def supported_function(self) -> str:
+        return "search"
+
+
+class CommandFormatter(ToolCallFormatter):
+    """
+    Command formatter
+    """
+
+    def format_input(self, call_id: str, function_name: str, arguments: str) -> Tuple[str, bool]:
+        try:
+            args = json.loads(arguments)
+            command = args.get("command", "")
+            return f"siada wants to run the following command: \n```bash \n{command}\n```", True
+        except json.JSONDecodeError:
+            return f"failed to parse arguments: {arguments}", False
+
+    @property
+    def supported_function(self) -> str:
+        return "run_cmd"
+    
+    def get_style(self) -> str:
+        return "markdown"
+
+
+class FixAttemptCompletionFormatter(ToolCallFormatter):
+    """
+    Formatter for the fix_attempt_completion function.
+    """
+
+    def format_input(
+        self, call_id: str, function_name: str, arguments: str
+    ) -> Tuple[str, bool]:
+
+        complete = False
+        content = ""
+        try:
+            # Use partial JSON parser to handle incomplete arguments
+            args = loads(arguments)
+            # Check if JSON is complete by comparing with ensured version
+            ensured_json = ensure_json(arguments)
+            if arguments == ensured_json:
+                complete = True
+
+            # Safely extract values, handling potential None/missing keys
+            result = args.get("result", "") if args else ""
+
+            if result:
+                content = f"The bug fix task has been successfully completed:\n{result}"
+                if complete:
+                    content += ""
+
+            return content, complete
+        except Exception as e:
+            return content + f"failed to parse arguments: {arguments}", False
+
+    @property
+    def supports_streaming(self) -> bool:
+        return False
+
+    @property
+    def supported_function(self) -> str:
+        return "fix_attempt_completion"
+
+    def get_style(self) -> str:
+        return "markdown"
+
+
+class ReproduceCompletionFormatter(ToolCallFormatter):
+    """
+    Formatter for the reproduce_completion function.
+    """
+
+    def format_input(self, call_id: str, function_name: str, arguments: str) -> Tuple[str, bool]:
+        try:
+            args = json.loads(arguments)
+            test_case = args.get("test_case", "")
+            bug_analysis = args.get("bug_analysis", "")
+            content = f"This issue can be reproduced using test case : {test_case}.\n Analysis of the issue: {bug_analysis}"
+            return content, True
+        except json.JSONDecodeError:
+            return f"failed to parse arguments: {arguments}", False
+
+    @property
+    def supported_function(self) -> str:
+        return "reproduce_completion"
+
+
+class WebCrawlFormatter(ToolCallFormatter):
+    """
+    Formatter for the web_crawl function.
+    """
+
+    def format_input(self, call_id: str, function_name: str, arguments: str) -> Tuple[str, bool]:
+        try:
+            args = json.loads(arguments)
+            url = args.get("url", "")
+            crawl_format = args.get("format", "text")
+            return f"siada wants to crawl the url: {url} with format {crawl_format}", True
+        except json.JSONDecodeError:
+            return f"failed to parse arguments: {arguments}", False
+
+    @property
+    def supported_function(self) -> str:
+        return "web_crawl"
+
+
+class AskFollowupQuestionFormatter(ToolCallFormatter):
+    """
+    Formatter for the ask_followup_question function.
+    """
+
+    def format_input(self, call_id: str, function_name: str, arguments: str) -> Tuple[str, bool]:
+        try:
+            args = json.loads(arguments)
+            question = args.get("question", "")
+            return f"{question}", True
+        except json.JSONDecodeError:
+            return f"failed to parse arguments: {arguments}", False
+
+    @property
+    def supported_function(self) -> str:
+        return "ask_followup_question" 
+
+
+class ListCodeDefinitionNamesFormatter(ToolCallFormatter):
+    """
+    Formatter for the list_code_definition_names function.
+    """
+
+    def format_input(self, call_id: str, function_name: str, arguments: str) -> Tuple[str, bool]:
+        try:
+            args = json.loads(arguments)
+            file_name = args.get("file_name", "Unknown file")
+            return f"siada wants to analyze definitions in `{file_name}`", True
+        except json.JSONDecodeError:
+            return "failed to parse arguments: {arguments}", False
+
+    @property
+    def supported_function(self) -> str:
+        return "list_code_definition_names"

siada/tools/tool_call_format/tool_call_formatter.py

@@ -0,0 +1,54 @@
+from abc import ABC, abstractmethod
+from typing import Any, Dict, Tuple
+
+
+class ToolCallFormatter(ABC):
+    """
+    Tool call formatter interface
+    Used to format input parameters for different functions
+    """
+
+    @abstractmethod
+    def format_input(self, call_id: str, function_name: str, arguments: str) -> Tuple[str, bool]:
+        """
+        Format function input parameters
+        
+        Args:
+            call_id: tool_call id
+            function_name: function name
+            arguments: raw parameter string
+            
+        Returns:
+            A tuple containing content and completeness flag (content, is_complete)
+        """
+        pass
+    
+    def supports_streaming(self) -> bool:
+        """
+        Whether streaming rendering is supported
+        
+        Returns:
+            True if this formatter supports streaming rendering, False otherwise
+        """
+        return False
+
+    @property
+    @abstractmethod
+    def supported_function(self) -> str:
+        """
+        Return the supported function name
+        
+        Returns:
+            The supported function name
+        """
+        pass 
+
+
+    def get_style(self) -> str:
+        """
+        Return the style
+        
+        Returns:
+            The style
+        """
+        return "text"