siada-cli 0.0.1__py3-none-any.whl

siada/tools/read_many_files/models.py

@@ -0,0 +1,189 @@
+"""
+ReadManyFiles tool data models and structures.
+"""
+
+from dataclasses import dataclass, field
+from typing import List, Dict, Optional, Union, Any
+
+
+@dataclass
+class ReadManyFilesParams:
+    """ReadManyFiles tool input parameters"""
+    
+    # Required parameters
+    paths: List[str]  # File paths or directory paths array, relative to tool config target directory
+                      # Can directly use glob patterns
+                      # Example: ['src/**/*.py', 'docs/*.md']
+    
+    # Optional parameters
+    include: Optional[List[str]] = None       # Additional include glob patterns
+                                              # Example: ["*.test.ts"]
+    
+    exclude: Optional[List[str]] = None       # Exclude glob patterns
+                                              # Example: ["*.log", "dist/**"]
+    
+    recursive: bool = True                    # Whether to search recursively
+                                              # Mainly controlled by "**" in glob patterns
+    
+    useDefaultExcludes: bool = True           # Whether to apply default exclude patterns
+    
+    file_filtering_options: Optional[Dict[str, bool]] = None
+    # File filtering options
+    # {
+    #     'respect_git_ignore': bool,     # Default: True
+    # }
+
+
+@dataclass
+class ToolResult:
+    """Tool execution result"""
+    
+    llmContent: Union[List[str], List[Any], List[Union[str, Any]]]
+    # Content returned to LLM
+    # - For text files: formatted string array
+    # - For images/PDF: Part object array
+    # - Mixed content: mixed array of strings and Part objects
+    
+    returnDisplay: str
+    # Content returned to user interface display
+    # Contains detailed summary information of processing results
+
+
+@dataclass
+class FileProcessResult:
+    """Single file processing result"""
+    
+    success: bool
+    path: str
+    content: Optional[Any] = None
+    reason: Optional[str] = None
+    file_type: Optional[str] = None
+    size: Optional[int] = None
+
+
+@dataclass
+class ProcessingStats:
+    """File processing statistics"""
+    
+    total_files_found: int = 0
+    processed_files: int = 0
+    skipped_files: int = 0
+    text_files: int = 0
+    image_files: int = 0
+    pdf_files: int = 0
+    binary_files: int = 0
+    error_files: int = 0
+    total_size: int = 0
+    processing_time: float = 0.0
+
+
+# Default exclude patterns
+DEFAULT_EXCLUDES = [
+    # Dependency directories
+    '**/node_modules/**',
+    '**/__pycache__/**',
+    '**/venv/**',
+    '**/env/**',
+    '**/.env/**',
+    
+    # Version control
+    '**/.git/**',
+    '**/.svn/**',
+    '**/.hg/**',
+    
+    # IDE configuration
+    '**/.vscode/**',
+    '**/.idea/**',
+    '**/.eclipse/**',
+    
+    # Build output
+    '**/dist/**',
+    '**/build/**',
+    '**/target/**',
+    '**/coverage/**',
+    '**/out/**',
+    
+    # Compiled files
+    '**/*.pyc',
+    '**/*.pyo',
+    '**/*.class',
+    '**/*.jar',
+    '**/*.war',
+    '**/*.o',
+    '**/*.obj',
+    
+    # Binary files
+    '**/*.bin',
+    '**/*.exe',
+    '**/*.dll',
+    '**/*.so',
+    '**/*.dylib',
+    
+    # Compressed files
+    '**/*.zip',
+    '**/*.tar',
+    '**/*.gz',
+    '**/*.bz2',
+    '**/*.rar',
+    '**/*.7z',
+    
+    # Office documents (unless explicitly requested)
+    '**/*.doc',
+    '**/*.docx',
+    '**/*.xls',
+    '**/*.xlsx',
+    '**/*.ppt',
+    '**/*.pptx',
+    '**/*.odt',
+    '**/*.ods',
+    '**/*.odp',
+    
+    # System files
+    '**/.DS_Store',
+    '**/Thumbs.db',
+    '**/.env',
+    '**/.env.local',
+    '**/.env.*.local',
+    
+    # Log files
+    '**/*.log',
+    '**/logs/**',
+    
+    # Cache directories
+    '**/.cache/**',
+    '**/cache/**',
+    '**/.tmp/**',
+    '**/tmp/**',
+    
+    # Package manager files
+    '**/package-lock.json',
+    '**/yarn.lock',
+    '**/poetry.lock',
+    '**/Pipfile.lock',
+    
+    # Gemini history files
+    '**/GEMINI.md',
+]
+
+# Supported text file extensions
+TEXT_FILE_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'
+}
+
+# Supported image file extensions
+IMAGE_FILE_EXTENSIONS = {
+    '.png', '.jpg', '.jpeg', '.gif', '.bmp', '.webp', '.svg', '.ico',
+    '.tiff', '.tif', '.psd', '.ai', '.eps'
+}
+
+# Supported PDF file extensions
+PDF_FILE_EXTENSIONS = {
+    '.pdf'
+}

siada/tools/read_many_files_tool.py

@@ -0,0 +1,233 @@
+"""
+ReadManyFiles tool - Batch read multiple files with intelligent filtering.
+
+This tool provides functionality to read multiple files based on glob patterns,
+with support for text files, images, and PDFs. It includes intelligent filtering
+using .gitignore rules and default exclusion patterns.
+"""
+
+import os
+import time
+import asyncio
+from typing import Dict, Any, Optional
+
+from .read_many_files.models import ReadManyFilesParams, ToolResult
+from .read_many_files.file_processor import FileProcessor
+from .read_many_files.filters import FileFilter
+from .read_many_files.formatters import ResultFormatter
+
+
+class ReadManyFilesTool:
+    """ReadManyFiles tool implementation"""
+    
+    def __init__(self, target_dir: Optional[str] = None):
+        """
+        Initialize ReadManyFiles tool
+        
+        Args:
+            target_dir: Target directory for file operations (defaults to current working directory)
+        """
+        self.target_dir = target_dir or os.getcwd()
+        self.file_processor = FileProcessor(self.target_dir)
+        self.file_filter = FileFilter(self.target_dir)
+        self.formatter = ResultFormatter(self.target_dir)
+    
+    def validate_params(self, params: ReadManyFilesParams) -> Optional[str]:
+        """
+        Validate input parameters
+        
+        Args:
+            params: ReadManyFilesParams object
+            
+        Returns:
+            Error message if validation fails, None if valid
+        """
+        if not params.paths:
+            return "Parameter 'paths' is required and cannot be empty"
+        
+        if not isinstance(params.paths, list):
+            return "Parameter 'paths' must be a list"
+        
+        if any(not isinstance(path, str) for path in params.paths):
+            return "All items in 'paths' must be strings"
+        
+        if params.include and not isinstance(params.include, list):
+            return "Parameter 'include' must be a list if provided"
+        
+        if params.exclude and not isinstance(params.exclude, list):
+            return "Parameter 'exclude' must be a list if provided"
+        
+        return None
+    
+    def merge_filtering_options(self, params: ReadManyFilesParams) -> Dict[str, bool]:
+        """
+        Merge filtering options with defaults
+        
+        Args:
+            params: ReadManyFilesParams object
+            
+        Returns:
+            Dictionary of filtering options
+        """
+        default_options = {
+            'respect_git_ignore': True
+        }
+        
+        if params.file_filtering_options:
+            default_options.update(params.file_filtering_options)
+        
+        return default_options
+    
+    async def execute(self, params: ReadManyFilesParams, signal=None) -> ToolResult:
+        """
+        Execute the ReadManyFiles tool
+        
+        Args:
+            params: ReadManyFilesParams object with tool parameters
+            signal: Cancellation signal (optional)
+            
+        Returns:
+            ToolResult object with processing results
+        """
+        start_time = time.time()
+        
+        try:
+            # 1. Parameter validation
+            validation_error = self.validate_params(params)
+            if validation_error:
+                return ToolResult(**self.formatter.create_error_result(validation_error))
+            
+            # 2. Configuration initialization
+            file_filtering_options = self.merge_filtering_options(params)
+            
+            # 3. Build search patterns
+            search_patterns = params.paths + (params.include or [])
+            if not search_patterns:
+                return ToolResult(**self.formatter.create_info_result("No search patterns provided"))
+            
+            exclusion_patterns = self.file_filter.build_exclusion_patterns(params)
+            
+            # 4. Execute file search
+            all_files = await self.file_processor.search_files_with_glob(
+                search_patterns, exclusion_patterns, signal
+            )
+            
+            if not all_files:
+                return ToolResult(**self.formatter.create_info_result(
+                    "No files found matching the specified patterns"
+                ))
+            
+            # 5. Apply ignore filters
+            filtered_files, filter_counts = self.file_filter.apply_gitignore_filters(
+                all_files, file_filtering_options
+            )
+            
+            # 6. Security validation
+            validated_files = self.file_filter.validate_workspace_security(filtered_files)
+            
+            if not validated_files:
+                return ToolResult(**self.formatter.create_info_result(
+                    "No files remain after filtering and security validation"
+                ))
+            
+            # 7. Read file contents
+            content_parts, processed_files, skipped_files = await self.file_processor.process_files(
+                validated_files, params.paths
+            )
+            
+            # 8. Add filter statistics to skipped files
+            filter_skip_info = self.formatter.build_filter_skip_info(filter_counts)
+            skipped_files.extend(filter_skip_info)
+            
+            # 9. Update processing time
+            end_time = time.time()
+            self.file_processor.stats.processing_time = end_time - start_time
+            
+            # 10. Build and return result
+            result_dict = self.formatter.build_result(
+                content_parts, processed_files, skipped_files, self.file_processor.stats
+            )
+            
+            return ToolResult(**result_dict)
+            
+        except Exception as error:
+            return ToolResult(**self.formatter.create_error_result(
+                f"Unexpected error during file processing: {str(error)}"
+            ))
+
+
+# Main function for tool execution
+async def read_many_files(params: ReadManyFilesParams, 
+                         target_dir: Optional[str] = None,
+                         signal=None) -> ToolResult:
+    """
+    Read multiple files based on glob patterns
+    
+    Args:
+        params: ReadManyFilesParams object with tool parameters
+        target_dir: Target directory for file operations (optional)
+        signal: Cancellation signal (optional)
+        
+    Returns:
+        ToolResult object with processing results
+    """
+    tool = ReadManyFilesTool(target_dir)
+    return await tool.execute(params, signal)
+
+
+# Convenience function for direct usage
+async def read_files_by_patterns(paths: list, 
+                                include: Optional[list] = None,
+                                exclude: Optional[list] = None,
+                                target_dir: Optional[str] = None,
+                                use_default_excludes: bool = True,
+                                respect_git_ignore: bool = True) -> ToolResult:
+    """
+    Convenience function to read files by patterns
+    
+    Args:
+        paths: List of file paths or glob patterns
+        include: Additional include patterns (optional)
+        exclude: Exclude patterns (optional)
+        target_dir: Target directory (optional)
+        use_default_excludes: Whether to use default exclusion patterns
+        respect_git_ignore: Whether to respect .gitignore rules
+        
+    Returns:
+        ToolResult object with processing results
+    """
+    params = ReadManyFilesParams(
+        paths=paths,
+        include=include,
+        exclude=exclude,
+        useDefaultExcludes=use_default_excludes,
+        file_filtering_options={
+            'respect_git_ignore': respect_git_ignore
+        }
+    )
+    
+    return await read_many_files(params, target_dir)
+
+
+if __name__ == "__main__":
+    # Example usage
+    import asyncio
+    
+    async def main():
+        # Example: Read all Python files in current directory
+        result = await read_files_by_patterns(
+            paths=["**/*.py"],
+            exclude=["**/test_*.py", "**/__pycache__/**"]
+        )
+        
+        print("LLM Content:")
+        for content in result.llmContent:
+            if isinstance(content, str):
+                print(content[:200] + "..." if len(content) > 200 else content)
+            else:
+                print(f"[Binary content: {content.get('type', 'unknown')}]")
+        
+        print("\nDisplay Message:")
+        print(result.returnDisplay)
+    
+    asyncio.run(main())

siada/tools/tool_call_format/__init__.py

@@ -0,0 +1,55 @@
+"""
+Tool Call Formatter 模块
+
+提供工具调用参数格式化功能，包括：
+- ToolCallFormatter 抽象基类接口
+- ToolCallFormatterFactory 工厂类
+- 各种具体的 formatter 实现
+- ParameterInterceptor 参数拦截装饰器
+"""
+
+from .tool_call_formatter import ToolCallFormatter
+from .formatter_factory import ToolCallFormatterFactory
+from .formatters import (
+    DefaultFormatter,
+    ListCodeDefinitionNamesFormatter,
+    SearchFormatter,
+    CommandFormatter,
+    FixAttemptCompletionFormatter,
+    ReproduceCompletionFormatter,
+    FileEditFormatter,
+    AskFollowupQuestionFormatter,
+)
+
+# 自动注册所有formatter
+def _register_all_formatters():
+    """自动注册所有可用的formatter"""
+    formatters = [
+        DefaultFormatter,
+        SearchFormatter,
+        CommandFormatter,
+        FixAttemptCompletionFormatter,
+        ReproduceCompletionFormatter,
+        FileEditFormatter,
+        AskFollowupQuestionFormatter,
+        ListCodeDefinitionNamesFormatter,
+    ]
+    
+    for formatter_class in formatters:
+        ToolCallFormatterFactory.register_formatter(formatter_class)
+
+# 在模块导入时自动注册
+_register_all_formatters()
+
+# 导出的公共接口
+__all__ = [
+    'ToolCallFormatter',
+    'ToolCallFormatterFactory',
+    'DefaultFormatter',
+    'FileReadFormatter',
+    'SearchFormatter',
+    'CommandFormatter',
+    'ParameterInterceptor',
+    'parameter_interceptor',
+    'simple_interceptor',
+]