siada-cli 0.0.1__py3-none-any.whl

siada/tools/coder/tool_docs.py

@@ -0,0 +1,44 @@
+EDIT_DOCS= """Custom editing tool for viewing, creating and editing files in plain-text format
+* State is persistent across command calls and discussions with the user
+* If `path` is a text file, `view` displays the result of applying `cat -n`. If `path` is a directory, `view` lists non-hidden files and directories up to 2 levels deep
+* The following binary file extensions can be viewed in Markdown format: [".xlsx", ".pptx", ".wav", ".mp3", ".m4a", ".flac", ".pdf", ".docx"]. IT DOES NOT HANDLE IMAGES.
+* The `create` command cannot be used if the specified `path` already exists as a file
+* If a `command` generates a long output, it will be truncated and marked with `<response clipped>`
+* The `undo_edit` command will revert the last edit made to the file at `path`
+* This tool can be used for creating and editing files in plain-text format.
+
+
+Before using this tool:
+1. Use the view tool to understand the file's contents and context
+2. Verify the directory path is correct (only applicable when creating new files):
+   - Use the view tool to verify the parent directory exists and is the correct location
+
+When making edits:
+   - Ensure the edit results in idiomatic, correct code
+   - Do not leave the code in a broken state
+   - Always use absolute file paths (starting with /)
+
+CRITICAL REQUIREMENTS FOR USING THIS TOOL:
+
+1. EXACT MATCHING: The `old_str` parameter must match EXACTLY one or more consecutive lines from the file, including all whitespace and indentation. The tool will fail if `old_str` matches multiple locations or doesn't match exactly with the file content.
+
+2. UNIQUENESS: The `old_str` must uniquely identify a single instance in the file:
+   - Include sufficient context before and after the change point (3-5 lines recommended)
+   - If not unique, the replacement will not be performed
+
+3. REPLACEMENT: The `new_str` parameter should contain the edited lines that replace the `old_str`. Both strings must be different.
+
+Remember: when making multiple file edits in a row to the same file, you should prefer to send all edits in a single message with multiple calls to this tool, rather than multiple messages with a single call each.
+
+Args:
+    command: The commands to run. Allowed options are: `view`, `create`, `str_replace`, `insert`, `undo_edit`.
+    path: Absolute path to file or directory, e.g. `/workspace/file.py` or `/workspace`.
+    file_text: Required parameter of `create` command, with the content of the file to be created.
+    old_str: Required parameter of `str_replace` command containing the string in `path` to replace.
+    new_str: Optional parameter of `str_replace` command containing the new string (if not given, no string will be added). Required parameter of `insert` command containing the string to insert.
+    insert_line: Required parameter of `insert` command. The `new_str` will be inserted AFTER the line `insert_line` of `path`.
+    view_range: Optional parameter of `view` command when `path` points to a file. If none is given, the full file is shown. If provided, the file will be shown in the indicated line number range, e.g. [11, 12] will show lines 11 and 12. Indexing at 1 to start. Setting `[start_line, -1]` shows all lines from `start_line` to the end of the file.
+
+
+
+"""

siada/tools/compression_tool.py

@@ -0,0 +1,200 @@
+"""
+Context Compression Tool - Intelligently compresses conversation history using a model.
+"""
+from __future__ import annotations
+
+import json
+from typing import Any
+
+from agents import RunContextWrapper, function_tool
+from agents.items import TResponseInputItem
+from openai.types.chat import ChatCompletionMessageParam
+from siada.foundation.code_agent_context import CodeAgentContext
+from siada.foundation.config import settings
+from siada.provider.client_factory import get_client_with_kwargs
+COMPRESS_DOCS = """Intelligently compress or summarize the conversation history within a specified range.
+
+    This tool should be called when the following situations occur:
+    1. The conversation history is too long and needs to be partially archived.
+    2. A task or topic has concluded, and the relevant conversation can be compressed.
+    3. Some messages are no longer important for resolving the current main task and need to be cleared.
+    4. The current conversation has deviated from the original topic and needs to be refocused.
+    5. The message list contains a lot of redundant information, which reduces the efficiency of accessing important content.
+    6. If the test required multiple steps to complete — or was not completed — you need to summarize the testing process.
+    7. If the search involved multiple steps — or returned too many results — you need to summarize the search process.
+    ===
+
+    After summarizing, you must provide a recommendation for the next step.
+
+    Args:
+        reason: The reason why context compression is needed (required).
+        start_index: The starting index of the compression range (inclusive).
+        end_index: The ending index of the compression range (exclusive).
+
+    Returns:
+        A dictionary containing:
+        - status (int): 1 for success, 0 for failure.
+        - start_index (int): The starting index of the compression.
+        - end_index (int): The ending index of the compression.
+        - summary (str): The compression summary or error/status information.
+
+    Example Usage:
+    
+    Original conversation history (messages 1-6):
+    [1] assistant: Search for files containing "config" keyword to find configuration files.
+    [2] tool: {"status": "success", "results": ["config.py", "app_config.py", "db_config.py", "test_config.py", "config.yaml", "nginx.conf", "docker-compose.yml"], "total": 47}
+    [3] assistant: Too many results. Search for "database config" specifically.
+    [4] tool: {"status": "success", "results": ["db_config.py", "database.conf", "config/db.yaml", "tests/db_config_test.py", "migrations/config.py"], "total": 23}
+    [5] assistant: Still too broad. Search for "database connection" in Python files only.
+    [6] tool: {"status": "success", "results": ["db_config.py", "models/base.py", "utils/db_helper.py", "services/db_service.py"], "total": 18}
+    [7] assistant: The search results are still not specific enough. Let me try a different approach.
+    [8] tool: {"status": "success", "message": "Search strategy needs refinement - too many generic matches"}
+
+    Compression call:
+    compress_context_tool(
+        reason="Search attempts yielded too many results, need to restart with better strategy",
+        start_index=1,
+        end_index=7,
+    )
+
+    Compressed result:
+    {
+        "status": 1,
+        "start_index": 1,
+        "end_index": 7,
+        "summary": "[Smart Compression Summary]\nReason for compression: Search attempts yielded too many results, need to restart with better strategy\nMultiple search attempts for configuration files returned excessive results (47, 23, 18 matches respectively), indicating search terms were too broad and strategy needs refinement."
+    }
+    """
+
+@function_tool(
+    name_override="compress_context_tool", description_override=COMPRESS_DOCS, failure_error_function=None
+)
+async def compress_context_tool(
+    context: RunContextWrapper[CodeAgentContext],
+    reason: str,
+    start_index: int,
+    end_index: int,
+) -> dict[str, Any]:
+
+    return await _compress_context_tool(
+        context=context,
+        reason=reason,
+        start_index=start_index,
+        end_index=end_index
+    )
+
+async def _compress_messages_with_model(messages: list[TResponseInputItem], reason: str, context: RunContextWrapper[CodeAgentContext]) -> str:
+    
+    
+    # Format messages
+    formatted_messages_content = []
+    for msg in messages:
+        role = msg.get("role", "unknown")
+        content_text = msg.get("content", "")
+        formatted_messages_content.append(f"{role}: {content_text}")
+    
+    conversation_text = "\n".join(formatted_messages_content)
+
+    # Build the system prompt to guide the model for a high-quality summary
+    system_prompt = f"""You are a professional conversation summarization assistant. Your task is to generate a concise, accurate, and fluent English summary based on the provided conversation history.
+
+The summary must meet the following requirements:
+1.  **Preserve Core Information**: Accurately capture the key topics, important decisions, and critical information of the conversation.
+2.  **Reflect Context**: The summary should clearly reflect the context and flow of the conversation, facilitating a seamless continuation.
+3.  **State the Reason for Compression**: Clearly state the reason for this compression at the beginning of the summary: "{reason}".
+4.  **Concise Language**: Use refined language, avoiding redundancy and unnecessary information.
+5.  **Clear Format**: The summary should start with "[Smart Compression Summary]".
+
+Please generate a summary based on the following conversation history:
+---
+{conversation_text}
+---
+"""
+
+    # Construct the request to be sent to the model
+    model_messages: list[ChatCompletionMessageParam] = [
+        {"role": "system", "content": system_prompt},
+        {"role": "user", "content": "Please generate a summary based on the above conversation history and requirements."}
+    ]
+
+    # Call the model for a non-streaming request
+    default_kwargs = {
+        "model": settings.Claude_4_0_SONNET,
+        "messages": model_messages,
+        "stream": False,
+        "temperature": 0.2,  # Lower temperature to ensure the determinism and accuracy of the summary
+    }
+    
+    # Use get_client_with_kwargs to support context parameter overrides
+    client, complete_kwargs = get_client_with_kwargs(context.context, default_kwargs)
+    response = await client.chat_complete(**complete_kwargs)
+    
+    # Extract the summary content from the response
+    if response and response.choices and response.choices[0].message:
+        summary = response.choices[0].message.content
+        if summary:
+            return summary.strip()
+
+    # If a valid summary cannot be obtained, return a default error message
+    return f"[Smart Compression Summary]\nReason for compression: {reason}\nSummary generation failed: Unable to retrieve valid summary content from the model."
+
+
+def _create_failure_response(start_index: int, end_index: int, summary: str) -> dict[str, Any]:
+    """Creates a response dictionary indicating failure."""
+    return {
+        "status": 0,
+        "start_index": start_index,
+        "end_index": end_index,
+        "summary": summary
+    }
+
+
+async def _compress_context_tool(
+    context: RunContextWrapper[CodeAgentContext],
+    reason: str,
+    start_index: int,
+    end_index: int,
+) -> dict[str, Any]:
+    if not context.context:
+        return _create_failure_response(start_index, end_index, "Error: Unable to get context information")
+
+    conversation_history = context.context.message_history
+    total_messages = len(conversation_history)
+    
+    original_start_index = start_index
+    original_end_index = end_index
+
+    # --- Input Validation ---
+    if start_index < 0 or end_index > total_messages or start_index >= end_index:
+        summary = f"Error: Invalid compression range. Valid range: 0 <= start < end <= {total_messages}"
+        return _create_failure_response(original_start_index, original_end_index, summary)
+
+    # As per user requirements, never compress the first message
+    if start_index == 0:
+        start_index = 1  # Force start from index 1
+        if start_index >= end_index:
+            summary = "No compression needed: The specified range only contains or is invalid after the first message."
+            return _create_failure_response(original_start_index, original_end_index, summary)
+
+    messages_to_compress = conversation_history[start_index:end_index]
+    messages_to_compress_count = len(messages_to_compress)
+
+    if messages_to_compress_count == 0:
+        summary = f"No compression needed: No messages within the range {start_index}-{end_index}."
+        return _create_failure_response(start_index, end_index, summary)
+
+    # --- Compress using the model ---
+    try:
+        compression_summary = await _compress_messages_with_model(messages_to_compress, reason)
+    except Exception as e:
+        return _create_failure_response(start_index, end_index, f"Error: Model compression failed - {str(e)}")
+
+    # As per user requirements, this tool is only responsible for generating a summary and does not modify message_history
+    # The actual replacement operation will be completed by other tools
+
+    return {
+        "status": 1,
+        "start_index": start_index,
+        "end_index": end_index,
+        "summary": compression_summary
+    }

siada/tools/read_many_files/README.md

@@ -0,0 +1,220 @@
+# ReadManyFiles Tool
+
+A powerful tool for batch reading multiple files with intelligent filtering and support for various file types.
+
+## Features
+
+- **Batch File Reading**: Read multiple files using glob patterns
+- **Intelligent Filtering**: Built-in support for .gitignore rules and default exclusion patterns
+- **Multiple File Types**: Support for text files, images, and PDFs
+- **Async Processing**: Concurrent file processing for better performance
+- **Security**: Path validation to ensure files are within workspace
+- **Detailed Reporting**: Comprehensive statistics and error reporting
+
+## Quick Start
+
+### Basic Usage
+
+```python
+import asyncio
+from siada.tools.read_many_files_tool import read_files_by_patterns
+
+async def main():
+    # Read all Python files in current directory
+    result = await read_files_by_patterns(
+        paths=["*.py"],
+        target_dir="."
+    )
+    
+    print(f"Found {len(result.llmContent)} files")
+    print(result.returnDisplay)
+
+asyncio.run(main())
+```
+
+### Advanced Usage
+
+```python
+from siada.tools.read_many_files_tool import ReadManyFilesTool
+from siada.tools.read_many_files.models import ReadManyFilesParams
+
+async def advanced_example():
+    # Create tool instance
+    tool = ReadManyFilesTool("/path/to/project")
+    
+    # Configure parameters
+    params = ReadManyFilesParams(
+        paths=["src/**/*.py", "docs/*.md"],
+        include=["*.test.py"],
+        exclude=["**/node_modules/**", "**/__pycache__/**"],
+        useDefaultExcludes=True,
+        file_filtering_options={
+            'respect_git_ignore': True
+        }
+    )
+    
+    # Execute
+    result = await tool.execute(params)
+    
+    # Process results
+    for content in result.llmContent:
+        if isinstance(content, str):
+            print("Text file content:", content[:100] + "...")
+        else:
+            print("Binary file:", content.get('type', 'unknown'))
+```
+
+## Parameters
+
+### ReadManyFilesParams
+
+- **paths** (List[str], required): File paths or glob patterns
+- **include** (List[str], optional): Additional include patterns
+- **exclude** (List[str], optional): Exclude patterns
+- **recursive** (bool, default=True): Whether to search recursively
+- **useDefaultExcludes** (bool, default=True): Apply default exclusion patterns
+- **file_filtering_options** (Dict[str, bool], optional): Filtering configuration
+
+### Glob Patterns
+
+The tool supports standard glob patterns:
+
+- `*.py` - All Python files in current directory
+- `**/*.py` - All Python files recursively
+- `src/**/*.js` - All JavaScript files in src directory and subdirectories
+- `docs/*.md` - All Markdown files in docs directory
+
+## File Type Support
+
+### Text Files
+
+Supported extensions: `.py`, `.js`, `.ts`, `.md`, `.txt`, `.json`, `.yaml`, `.xml`, `.html`, `.css`, and many more.
+
+Text files are read with automatic encoding detection and include content truncation for large files.
+
+### Image Files
+
+Supported extensions: `.png`, `.jpg`, `.jpeg`, `.gif`, `.bmp`, `.webp`, `.svg`
+
+Images are converted to base64-encoded Part objects for LLM processing. Must be explicitly requested by filename or extension.
+
+### PDF Files
+
+Supported extension: `.pdf`
+
+PDFs are converted to Part objects for LLM processing. Must be explicitly requested by filename.
+
+## Filtering
+
+### Default Excludes
+
+The tool automatically excludes common non-source files:
+
+- Dependency directories: `node_modules`, `__pycache__`, `venv`
+- Version control: `.git`, `.svn`
+- IDE files: `.vscode`, `.idea`
+- Build outputs: `dist`, `build`, `target`
+- Binary files: `.exe`, `.dll`, `.so`
+- Compressed files: `.zip`, `.tar`, `.gz`
+
+### Git Ignore Support
+
+The tool respects `.gitignore` files by default. This can be disabled by setting:
+
+```python
+file_filtering_options={'respect_git_ignore': False}
+```
+
+## Output Format
+
+### ToolResult
+
+The tool returns a `ToolResult` object with:
+
+- **llmContent**: List of file contents (strings for text, Part objects for binary)
+- **returnDisplay**: Human-readable summary with statistics
+
+### Text File Format
+
+Text files are formatted with separators:
+
+```
+--- /path/to/file.py ---
+
+def hello():
+    print("Hello, World!")
+
+```
+
+## Error Handling
+
+The tool gracefully handles various error conditions:
+
+- File not found
+- Permission denied
+- Encoding errors
+- Large files (automatic truncation)
+- Binary files (skipped unless explicitly requested)
+
+## Performance
+
+- **Concurrent Processing**: Files are processed concurrently with configurable limits
+- **Memory Efficient**: Large files are truncated to prevent memory issues
+- **Caching**: Git ignore rules are cached for better performance
+
+## Examples
+
+### Read Configuration Files
+
+```python
+result = await read_files_by_patterns(
+    paths=["*.json", "*.yaml", "*.toml"],
+    target_dir="/path/to/config"
+)
+```
+
+### Read Source Code (Excluding Tests)
+
+```python
+result = await read_files_by_patterns(
+    paths=["src/**/*.py"],
+    exclude=["**/test_*.py", "**/tests/**"],
+    target_dir="/path/to/project"
+)
+```
+
+### Read Documentation
+
+```python
+result = await read_files_by_patterns(
+    paths=["docs/**/*.md", "README.md"],
+    target_dir="/path/to/project"
+)
+```
+
+### Read Images (Explicit Request)
+
+```python
+result = await read_files_by_patterns(
+    paths=["assets/*.png", "images/*.jpg"],
+    target_dir="/path/to/project"
+)
+```
+
+## Testing
+
+Run the test suite:
+
+```bash
+pytest tests/tools/test_read_many_files_tool.py -v
+```
+
+Run specific tests:
+
+```bash
+pytest tests/tools/test_read_many_files_tool.py::TestReadManyFilesTool::test_execute_success -v
+```
+
+## License
+
+This tool is part of the siada-agenthub project.

siada/tools/read_many_files/__init__.py

@@ -0,0 +1,25 @@
+"""
+ReadManyFiles tool package.
+"""
+
+from .models import (
+    ReadManyFilesParams,
+    ToolResult,
+    FileProcessResult,
+    ProcessingStats,
+    DEFAULT_EXCLUDES,
+    TEXT_FILE_EXTENSIONS,
+    IMAGE_FILE_EXTENSIONS,
+    PDF_FILE_EXTENSIONS,
+)
+
+__all__ = [
+    "ReadManyFilesParams",
+    "ToolResult", 
+    "FileProcessResult",
+    "ProcessingStats",
+    "DEFAULT_EXCLUDES",
+    "TEXT_FILE_EXTENSIONS",
+    "IMAGE_FILE_EXTENSIONS", 
+    "PDF_FILE_EXTENSIONS",
+]