siada-cli 0.0.1__py3-none-any.whl

siada/tools/coder/file_search/test_search.py

@@ -0,0 +1,142 @@
+"""
+Simple test script to verify the file_search functionality.
+"""
+
+import os
+import tempfile
+from pathlib import Path
+try:
+    from .search import regex_search_files, RipgrepSearcher
+except ImportError:
+    from search import regex_search_files, RipgrepSearcher
+
+
+def create_test_files():
+    """Create temporary test files for testing."""
+    test_dir = Path(tempfile.mkdtemp())
+    
+    # Create test Python file
+    python_file = test_dir / "test.py"
+    python_file.write_text("""
+def hello_world():
+    # TODO: Add proper greeting
+    print("Hello, World!")
+    return "success"
+
+class TestClass:
+    def __init__(self):
+        # FIXME: Initialize properly
+        self.value = 42
+    
+    def process_data(self, data):
+        # TODO: Implement data processing
+        return data * 2
+""")
+    
+    # Create test JavaScript file
+    js_file = test_dir / "test.js"
+    js_file.write_text("""
+function greet(name) {
+    // TODO: Add validation
+    console.log(`Hello, ${name}!`);
+}
+
+const utils = {
+    // FIXME: Add error handling
+    multiply: (a, b) => a * b
+};
+""")
+    
+    return test_dir
+
+
+def test_basic_functionality():
+    """Test basic search functionality."""
+    print("Creating test files...")
+    test_dir = create_test_files()
+    searcher = RipgrepSearcher()
+    try:
+        print(f"Test directory: {test_dir}")
+        
+        # Test 1: Search for TODO comments in Python files
+        print("\n=== Test 1: Search for TODO comments in Python files ===")
+        try:
+            results = searcher.search_in_files(
+                cwd=str(test_dir),
+                directory_path=str(test_dir),
+                regex=r"TODO:",
+                file_pattern="*.py"
+            )
+            print(results)
+        except RuntimeError as e:
+            print(f"Error: {e}")
+            print("Note: This error is expected if ripgrep binary is not installed.")
+        
+        # Test 2: Search for function definitions
+        print("\n=== Test 2: Search for function definitions ===")
+        try:
+
+            results = searcher.search_in_files(
+                directory_path=str(test_dir),
+                regex=r"def\s+\w+\(|function\s+\w+\(",
+                file_pattern="*",
+                cwd=str(test_dir)
+            )
+            print(results)
+        except RuntimeError as e:
+            print(f"Error: {e}")
+            print("Note: This error is expected if ripgrep binary is not installed.")
+        
+        # Test 3: Search for all TODO/FIXME comments
+        print("\n=== Test 3: Search for all TODO/FIXME comments ===")
+        try:
+            searcher = RipgrepSearcher()
+            results = searcher.search_in_files(
+                directory_path=str(test_dir),
+                regex=r"TODO:|FIXME:",
+                file_pattern="*",
+                cwd=str(test_dir)
+            )
+            print(results)
+        except RuntimeError as e:
+            print(f"Error: {e}")
+            print("Note: This error is expected if ripgrep binary is not installed.")
+            
+    finally:
+        # Clean up test files
+        import shutil
+        shutil.rmtree(test_dir)
+        print(f"\nCleaned up test directory: {test_dir}")
+
+
+def test_binary_detection():
+    """Test ripgrep binary detection."""
+    print("\n=== Binary Detection Test ===")
+    try:
+        searcher = RipgrepSearcher()
+        print(f"✓ Ripgrep binary found at: {searcher.rg_path}")
+        return True
+    except RuntimeError as e:
+        print(f"✗ {e}")
+        print("\nTo fix this:")
+        print("1. Download ripgrep from: https://github.com/BurntSushi/ripgrep/releases")
+        print("2. Place the binary in file_search/bin/ directory")
+        print("3. Rename according to platform (see README.md)")
+        print("4. Set execute permissions on Unix systems: chmod +x file_search/bin/rg-*")
+        return False
+
+
+if __name__ == "__main__":
+    """
+    运行测试用例需要先注释掉 search.py 中的 @function_tool注解
+    """
+    print("File Search - Test Script")
+    print("=" * 40)
+    
+    # Test binary detection first
+    if test_binary_detection():
+        # If binary is found, run functionality tests
+        test_basic_functionality()
+    else:
+        print("\nSkipping functionality tests due to missing ripgrep binary.")
+        print("Please install ripgrep binary as described above and try again.")

siada/tools/coder/files.py

@@ -0,0 +1,147 @@
+import os
+from pathlib import Path
+
+from siada.tools.coder.observation.error import ErrorObservation
+from siada.tools.coder.observation.file_observation import FileReadObservation, FileWriteObservation
+from siada.tools.coder.observation.observation import FunctionCallResult
+
+
+def resolve_path(
+    file_path: str,
+    working_directory: str,
+    workspace_base: str,
+    workspace_mount_path_in_sandbox: str,
+) -> Path:
+    """Resolve a file path to a path on the host filesystem.
+
+    Args:
+        file_path: The path to resolve.
+        working_directory: The working directory of the agent.
+        workspace_mount_path_in_sandbox: The path to the workspace inside the sandbox.
+        workspace_base: The base path of the workspace on the host filesystem.
+
+    Returns:
+        The resolved path on the host filesystem.
+    """
+    path_in_sandbox = Path(file_path)
+
+    # Apply working directory
+    if not path_in_sandbox.is_absolute():
+        path_in_sandbox = Path(working_directory) / path_in_sandbox
+
+    # Sanitize the path with respect to the root of the full sandbox
+    # (deny any .. path traversal to parent directories of the sandbox)
+    abs_path_in_sandbox = path_in_sandbox.resolve()
+
+    # If the path is outside the workspace, deny it
+    if not abs_path_in_sandbox.is_relative_to(workspace_mount_path_in_sandbox):
+        raise PermissionError(f'File access not permitted: {file_path}')
+
+    # Get path relative to the root of the workspace inside the sandbox
+    path_in_workspace = abs_path_in_sandbox.relative_to(
+        Path(workspace_mount_path_in_sandbox)
+    )
+
+    # Get path relative to host
+    path_in_host_workspace = Path(workspace_base) / path_in_workspace
+
+    return path_in_host_workspace
+
+
+def read_lines(all_lines: list[str], start: int = 0, end: int = -1) -> list[str]:
+    start = max(start, 0)
+    start = min(start, len(all_lines))
+    end = -1 if end == -1 else max(end, 0)
+    end = min(end, len(all_lines))
+    if end == -1:
+        if start == 0:
+            return all_lines
+        else:
+            return all_lines[start:]
+    else:
+        num_lines = len(all_lines)
+        begin = max(0, min(start, num_lines - 2))
+        end = -1 if end > num_lines else max(begin + 1, end)
+        return all_lines[begin:end]
+
+
+async def read_file(
+    path: str,
+    workdir: str,
+    workspace_base: str,
+    workspace_mount_path_in_sandbox: str,
+    start: int = 0,
+    end: int = -1,
+) -> FunctionCallResult:
+    try:
+        whole_path = resolve_path(
+            path, workdir, workspace_base, workspace_mount_path_in_sandbox
+        )
+    except PermissionError:
+        return ErrorObservation(
+            f"You're not allowed to access this path: {path}. You can only access paths inside the workspace."
+        )
+
+    try:
+        with open(whole_path, 'r', encoding='utf-8') as file:  # noqa: ASYNC101
+            lines = read_lines(file.readlines(), start, end)
+    except FileNotFoundError:
+        return ErrorObservation(f'File not found: {path}')
+    except UnicodeDecodeError:
+        return ErrorObservation(f'File could not be decoded as utf-8: {path}')
+    except IsADirectoryError:
+        return ErrorObservation(f'Path is a directory: {path}. You can only read files')
+    code_view = ''.join(lines)
+    return FileReadObservation(path=path, content=code_view)
+
+
+def insert_lines(
+    to_insert: list[str], original: list[str], start: int = 0, end: int = -1
+) -> list[str]:
+    """Insert the new content to the original content based on start and end"""
+    new_lines = [''] if start == 0 else original[:start]
+    new_lines += [i + '\n' for i in to_insert]
+    new_lines += [''] if end == -1 else original[end:]
+    return new_lines
+
+
+async def write_file(
+    path: str,
+    workdir: str,
+    workspace_base: str,
+    workspace_mount_path_in_sandbox: str,
+    content: str,
+    start: int = 0,
+    end: int = -1,
+) -> FunctionCallResult:
+    insert = content.split('\n')
+
+    try:
+        whole_path = resolve_path(
+            path, workdir, workspace_base, workspace_mount_path_in_sandbox
+        )
+        if not os.path.exists(os.path.dirname(whole_path)):
+            os.makedirs(os.path.dirname(whole_path))
+        mode = 'w' if not os.path.exists(whole_path) else 'r+'
+        try:
+            with open(whole_path, mode, encoding='utf-8') as file:  # noqa: ASYNC101
+                if mode != 'w':
+                    all_lines = file.readlines()
+                    new_file = insert_lines(insert, all_lines, start, end)
+                else:
+                    new_file = [i + '\n' for i in insert]
+
+                file.seek(0)
+                file.writelines(new_file)
+                file.truncate()
+        except FileNotFoundError:
+            return ErrorObservation(f'File not found: {path}')
+        except IsADirectoryError:
+            return ErrorObservation(
+                f'Path is a directory: {path}. You can only write to files'
+            )
+        except UnicodeDecodeError:
+            return ErrorObservation(f'File could not be decoded as utf-8: {path}')
+    except PermissionError as e:
+        return ErrorObservation(f'Permission error on {path}: {e}')
+    return FileWriteObservation(content='', path=path)

siada/tools/coder/fix_attempt_completion.py

@@ -0,0 +1,58 @@
+from agents import function_tool, RunContextWrapper
+from siada.foundation.code_agent_context import CodeAgentContext
+from siada.tools.coder.observation.observation import FunctionCallResult
+
+
+class FixAttemptCompletionResult(FunctionCallResult):
+
+    def __init__(self, content: str):
+        super().__init__(content=content)
+
+    def __str__(self):
+        return self.content
+
+    def format_for_display(self):
+        return "Bug Fix Task Status: COMPLETED"
+
+
+@function_tool(
+    name_override="fix_attempt_completion",
+    description_override="Complete the bug fix task and mark it as finished. This tool MUST be called to properly complete any bug fix task. Failure to call this tool means the bug fix task is incomplete and unacceptable."
+)
+async def fix_attempt_completion(
+    context: RunContextWrapper[CodeAgentContext],
+    result: str,
+) -> FunctionCallResult:
+    """
+    Complete the bug fix task and mark it as finished.
+    
+    IMPORTANT NOTE: This tool MUST be called to properly complete any bug fix task. Failure to call this tool means the bug fix task is incomplete and unacceptable. Before completing any bug fix work, you must ask yourself if you have successfully fixed all the bugs mentioned in the task. If not, then DO NOT use this tool until all bugs are fixed.
+    
+    Args:
+        context: The run context wrapper containing agent context
+        result: (required) A detailed summary of the bug fix work completed, including:
+                - Summary of the bug fix logic
+                - What changes were made
+                - What files were modified
+                - Any testing or verification performed        
+    Returns:
+        Observation: A completion observation with the fix summary
+        
+    Example:
+        fix_attempt_completion(
+            result="Successfully fixed the login authentication bug. Modified auth.py to properly validate user credentials and updated the password hashing algorithm. All tests are now passing.",
+        )
+    """
+    
+    # Format the completion message
+    completion_message = f"""
+=== Bug Fix Completed ===
+
+{result}
+
+"""
+
+
+    return FixAttemptCompletionResult(
+        content=completion_message,
+    )

siada/tools/coder/issue_review_completion.py

@@ -0,0 +1,29 @@
+from agents import RunContextWrapper, function_tool
+
+from siada.foundation.code_agent_context import CodeAgentContext
+
+
+ISSUE_REVIEW_COMPLETION_DOCS = f"""Issue Review Completion Tool
+
+This tool is called when completing an issue review process. It captures the final assessment of whether an issue has been successfully resolved.
+
+Parameters:
+- is_fixed (bool): Indicates whether the issue has been fixed. True if the issue is fixed, False if the issue is not fixed.
+- check_summary (str): The review conclusion summary. When is_fixed is False, this summary must be very detailed, explaining what aspects of the issue remain unresolved, what problems were found during the review, and what additional work is needed. Must include:
+   - Specific basis for fix status judgment
+   - If not fixed, clearly explain reasons for non-fix
+   - If fixed, assess implementation quality and potential risks
+   - Specific improvement suggestions or alternative solutions
+
+"""
+
+
+@function_tool(
+    name_override="issue_review_completion", description_override=ISSUE_REVIEW_COMPLETION_DOCS, failure_error_function=None
+)
+async def issue_review_completion(context: RunContextWrapper[CodeAgentContext], is_fixed: bool,
+                                  check_summary: str) -> dict:
+    return {
+        "is_fixed": is_fixed,
+        "check_summary": check_summary
+    }

siada/tools/coder/observation/error.py

@@ -0,0 +1,22 @@
+from dataclasses import dataclass
+
+from siada.tools.coder.observation.observation import FunctionCallResult
+
+
+@dataclass
+class ErrorObservation(FunctionCallResult):
+    """This data class represents an error encountered by the agent.
+
+    This is the type of error that LLM can recover from.
+    E.g., Linter error after editing a file.
+    """
+
+    observation: str = 'error'
+    error_id: str = ''
+
+    @property
+    def message(self) -> str:
+        return self.content
+
+    def __str__(self) -> str:
+        return f'**ErrorObservation**\n{self.content}'

siada/tools/coder/observation/file_observation.py

@@ -0,0 +1,216 @@
+from dataclasses import dataclass
+from difflib import SequenceMatcher
+
+import re
+from siada.tools.coder.observation.observation import FunctionCallResult, FileReadSource, ObservationType, FileEditSource
+
+
+@dataclass
+class FileReadObservation(FunctionCallResult):
+    """This data class represents the content of a file."""
+
+    path: str
+    observation: str = ObservationType.READ
+    impl_source: FileReadSource = FileReadSource.DEFAULT
+
+    @property
+    def message(self) -> str:
+        """Get a human-readable message describing the file read operation."""
+        return f'I read the file {self.path}.'
+
+    def __str__(self) -> str:
+        """Get a string representation of the file read observation."""
+        return f'[Read from {self.path} is successful.]\n{self.content}'
+
+@dataclass
+class FileWriteObservation(FunctionCallResult):
+    """This data class represents a file write operation."""
+
+    path: str
+    observation: str = ObservationType.WRITE
+
+    @property
+    def message(self) -> str:
+        """Get a human-readable message describing the file write operation."""
+        return f'I wrote to the file {self.path}.'
+    
+    def format_for_display(self) -> str:
+        return self.message
+
+    def __str__(self) -> str:
+        """Get a string representation of the file write observation."""
+        return f'[Write to {self.path} is successful.]\n{self.content}'
+
+
+@dataclass
+class FileEditObservation(FunctionCallResult):
+    """This data class represents a file edit operation.
+
+    The observation includes both the old and new content of the file, and can
+    generate a diff visualization showing the changes. The diff is computed lazily
+    and cached to improve performance.
+
+    The .content property can either be:
+      - Git diff in LLM-based editing mode
+      - the rendered message sent to the LLM in OH_ACI mode (e.g., "The file /path/to/file.txt is created with the provided content.")
+    """
+
+    path: str = ''
+    prev_exist: bool = False
+    old_content: str | None = None
+    new_content: str | None = None
+    observation: str = ObservationType.EDIT
+    impl_source: FileEditSource = FileEditSource.LLM_BASED_EDIT
+    diff: str | None = (
+        None  # The raw diff between old and new content, used in OH_ACI mode
+    )
+    _diff_cache: str | None = (
+        None  # Cache for the diff visualization, used in LLM-based editing mode
+    )
+    command: str = "unknown"
+
+    @property
+    def message(self) -> str:
+        # Check if path is likely a file or directory
+        import os.path
+        try:
+            is_file = bool(os.path.splitext(str(self.path))[1]) if self.path else True
+        except Exception:
+            # if path is invalid, default to directory
+            is_file = False
+            
+        if self.command == "view":
+            return "✓ File content loaded" if is_file else "✓ Directory listing completed"
+        elif self.command == "create":
+            return "✓ File created successfully" if is_file else "✓ Directory created successfully"
+        elif self.command == "str_replace":
+            return "✓ Text replacement completed"
+        elif self.command == "insert":
+            return "✓ Content insertion completed"
+        elif self.command == "undo_edit":
+            return "✓ Edit operation reverted"
+        else:
+            return "✓ Operation completed successfully"
+
+    def format_for_display(self) -> str:
+        return self.message
+
+    def get_edit_groups(self, n_context_lines: int = 2) -> list[dict[str, list[str]]]:
+        """Get the edit groups showing changes between old and new content.
+
+        Args:
+            n_context_lines: Number of context lines to show around each change.
+
+        Returns:
+            A list of edit groups, where each group contains before/after edits.
+        """
+        if self.old_content is None or self.new_content is None:
+            return []
+        old_lines = self.old_content.split('\n')
+        new_lines = self.new_content.split('\n')
+        # Borrowed from difflib.unified_diff to directly parse into structured format
+        edit_groups: list[dict] = []
+        for group in SequenceMatcher(None, old_lines, new_lines).get_grouped_opcodes(
+            n_context_lines
+        ):
+            # Take the max line number in the group
+            _indent_pad_size = len(str(group[-1][3])) + 1  # +1 for "*" prefix
+            cur_group: dict[str, list[str]] = {
+                'before_edits': [],
+                'after_edits': [],
+            }
+            for tag, i1, i2, j1, j2 in group:
+                if tag == 'equal':
+                    for idx, line in enumerate(old_lines[i1:i2]):
+                        line_num = i1 + idx + 1
+                        cur_group['before_edits'].append(
+                            f'{line_num:>{_indent_pad_size}}|{line}'
+                        )
+                    for idx, line in enumerate(new_lines[j1:j2]):
+                        line_num = j1 + idx + 1
+                        cur_group['after_edits'].append(
+                            f'{line_num:>{_indent_pad_size}}|{line}'
+                        )
+                    continue
+                if tag in {'replace', 'delete'}:
+                    for idx, line in enumerate(old_lines[i1:i2]):
+                        line_num = i1 + idx + 1
+                        cur_group['before_edits'].append(
+                            f'-{line_num:>{_indent_pad_size - 1}}|{line}'
+                        )
+                if tag in {'replace', 'insert'}:
+                    for idx, line in enumerate(new_lines[j1:j2]):
+                        line_num = j1 + idx + 1
+                        cur_group['after_edits'].append(
+                            f'+{line_num:>{_indent_pad_size - 1}}|{line}'
+                        )
+            edit_groups.append(cur_group)
+        return edit_groups
+
+    def visualize_diff(
+        self,
+        n_context_lines: int = 2,
+        change_applied: bool = True,
+    ) -> str:
+        """Visualize the diff of the file edit. Used in the LLM-based editing mode.
+
+        Instead of showing the diff line by line, this function shows each hunk
+        of changes as a separate entity.
+
+        Args:
+            n_context_lines: Number of context lines to show before/after changes.
+            change_applied: Whether changes are applied. If false, shows as
+                attempted edit.
+
+        Returns:
+            A string containing the formatted diff visualization.
+        """
+        # Use cached diff if available
+        if self._diff_cache is not None:
+            return self._diff_cache
+
+        # Check if there are any changes
+        if change_applied and self.old_content == self.new_content:
+            msg = '(no changes detected. Please make sure your edits change '
+            msg += 'the content of the existing file.)\n'
+            self._diff_cache = msg
+            return self._diff_cache
+
+        edit_groups = self.get_edit_groups(n_context_lines=n_context_lines)
+
+        if change_applied:
+            header = f'[Existing file {self.path} is edited with '
+            header += f'{len(edit_groups)} changes.]'
+        else:
+            header = f"[Changes are NOT applied to {self.path} - Here's how "
+            header += 'the file looks like if changes are applied.]'
+        result = [header]
+
+        op_type = 'edit' if change_applied else 'ATTEMPTED edit'
+        for i, cur_edit_group in enumerate(edit_groups):
+            if i != 0:
+                result.append('-------------------------')
+            result.append(f'[begin of {op_type} {i + 1} / {len(edit_groups)}]')
+            result.append(f'(content before {op_type})')
+            result.extend(cur_edit_group['before_edits'])
+            result.append(f'(content after {op_type})')
+            result.extend(cur_edit_group['after_edits'])
+            result.append(f'[end of {op_type} {i + 1} / {len(edit_groups)}]')
+
+        # Cache the result
+        self._diff_cache = '\n'.join(result)
+        return self._diff_cache
+
+    def __str__(self) -> str:
+        """Get a string representation of the file edit observation."""
+        if self.impl_source == FileEditSource.OH_ACI:
+            return self.content
+
+        if not self.prev_exist:
+            assert self.old_content == '', (
+                'old_content should be empty if the file is new (prev_exist=False).'
+            )
+            return f'[New file {self.path} is created with the provided content.]\n'
+
+        # Use cached diff if available, otherwise compute it
+        return self.visualize_diff().rstrip() + '\n'

siada/tools/coder/observation/observation.py

@@ -0,0 +1,71 @@
+from dataclasses import dataclass
+from enum import Enum
+
+class ObservationType(str, Enum):
+    READ = 'read'
+    """The content of a file
+    """
+
+    WRITE = 'write'
+
+    EDIT = 'edit'
+
+    BROWSE = 'browse'
+    """The HTML content of a URL
+    """
+
+    RUN = 'run'
+    """The output of a command
+    """
+
+    RUN_IPYTHON = 'run_ipython'
+    """Runs a IPython cell.
+    """
+
+    CHAT = 'chat'
+    """A message from the user
+    """
+
+    DELEGATE = 'delegate'
+    """The result of a task delegated to another agent
+    """
+
+    MESSAGE = 'message'
+
+    ERROR = 'error'
+
+    SUCCESS = 'success'
+
+    NULL = 'null'
+
+    THINK = 'think'
+
+    AGENT_STATE_CHANGED = 'agent_state_changed'
+
+    USER_REJECTED = 'user_rejected'
+
+    CONDENSE = 'condense'
+    """Result of a condensation operation."""
+
+    RECALL = 'recall'
+    """Result of a recall operation. This can be the workspace context, a microagent, or other types of information."""
+
+    MCP = 'mcp'
+    """Result of a MCP Server operation"""
+
+
+class FileReadSource(str, Enum):
+    OH_ACI = 'oh_aci'  # openhands-aci
+    DEFAULT = 'default'
+
+class FileEditSource(str, Enum):
+    LLM_BASED_EDIT = 'llm_based_edit'
+    OH_ACI = 'oh_aci'  # openhands-aci
+
+
+@dataclass
+class FunctionCallResult:
+    content: str
+
+    def format_for_display(self) -> str:
+        return self.__str__()