tunacode-cli 0.0.55__py3-none-any.whl → 0.0.78.6__py3-none-any.whl

tunacode/tools/read_file_async_poc.py

@@ -1,196 +0,0 @@
-"""
-Proof of Concept: Async-optimized read_file tool
-
-This demonstrates how we can make the read_file tool truly async
-by using asyncio.to_thread (Python 3.9+) or run_in_executor.
-"""
-
-import asyncio
-import os
-import sys
-from concurrent.futures import ThreadPoolExecutor
-from typing import Optional
-
-from tunacode.constants import (
-    ERROR_FILE_DECODE,
-    ERROR_FILE_DECODE_DETAILS,
-    ERROR_FILE_NOT_FOUND,
-    ERROR_FILE_TOO_LARGE,
-    MAX_FILE_SIZE,
-    MSG_FILE_SIZE_LIMIT,
-)
-from tunacode.exceptions import ToolExecutionError
-from tunacode.tools.base import FileBasedTool
-from tunacode.types import ToolResult
-
-# Shared thread pool for I/O operations
-# This avoids creating multiple thread pools
-_IO_THREAD_POOL: Optional[ThreadPoolExecutor] = None
-
-
-def get_io_thread_pool() -> ThreadPoolExecutor:
-    """Get or create the shared I/O thread pool."""
-    global _IO_THREAD_POOL
-    if _IO_THREAD_POOL is None:
-        max_workers = min(32, (os.cpu_count() or 1) * 4)
-        _IO_THREAD_POOL = ThreadPoolExecutor(
-            max_workers=max_workers, thread_name_prefix="tunacode-io"
-        )
-    return _IO_THREAD_POOL
-
-
-class AsyncReadFileTool(FileBasedTool):
-    """Async-optimized tool for reading file contents."""
-
-    @property
-    def tool_name(self) -> str:
-        return "Read"
-
-    async def _execute(self, filepath: str) -> ToolResult:
-        """Read the contents of a file asynchronously.
-
-        Args:
-            filepath: The path to the file to read.
-
-        Returns:
-            ToolResult: The contents of the file or an error message.
-
-        Raises:
-            Exception: Any file reading errors
-        """
-        # Check file size first (this is fast)
-        try:
-            file_size = os.path.getsize(filepath)
-        except FileNotFoundError:
-            raise FileNotFoundError(f"File not found: {filepath}")
-
-        if file_size > MAX_FILE_SIZE:
-            err_msg = ERROR_FILE_TOO_LARGE.format(filepath=filepath) + MSG_FILE_SIZE_LIMIT
-            if self.ui:
-                await self.ui.error(err_msg)
-            raise ToolExecutionError(tool_name=self.tool_name, message=err_msg, original_error=None)
-
-        # Read file asynchronously
-        content = await self._read_file_async(filepath)
-        return content
-
-    async def _read_file_async(self, filepath: str) -> str:
-        """Read file contents without blocking the event loop."""
-
-        # Method 1: Using asyncio.to_thread (Python 3.9+)
-        if sys.version_info >= (3, 9):
-
-            def _read_sync():
-                with open(filepath, "r", encoding="utf-8") as file:
-                    return file.read()
-
-            try:
-                return await asyncio.to_thread(_read_sync)
-            except Exception:
-                # Re-raise to be handled by _handle_error
-                raise
-
-        # Method 2: Using run_in_executor (older Python versions)
-        else:
-
-            def _read_sync(path):
-                with open(path, "r", encoding="utf-8") as file:
-                    return file.read()
-
-            loop = asyncio.get_event_loop()
-            executor = get_io_thread_pool()
-
-            try:
-                return await loop.run_in_executor(executor, _read_sync, filepath)
-            except Exception:
-                # Re-raise to be handled by _handle_error
-                raise
-
-    async def _handle_error(self, error: Exception, filepath: str = None) -> ToolResult:
-        """Handle errors with specific messages for common cases.
-
-        Raises:
-            ToolExecutionError: Always raised with structured error information
-        """
-        if isinstance(error, FileNotFoundError):
-            err_msg = ERROR_FILE_NOT_FOUND.format(filepath=filepath)
-        elif isinstance(error, UnicodeDecodeError):
-            err_msg = (
-                ERROR_FILE_DECODE.format(filepath=filepath)
-                + " "
-                + ERROR_FILE_DECODE_DETAILS.format(error=error)
-            )
-        else:
-            # Use parent class handling for other errors
-            await super()._handle_error(error, filepath)
-            return  # super() will raise, this is unreachable
-
-        if self.ui:
-            await self.ui.error(err_msg)
-
-        raise ToolExecutionError(tool_name=self.tool_name, message=err_msg, original_error=error)
-
-
-# Create the async function that maintains the existing interface
-async def read_file_async(filepath: str) -> str:
-    """
-    Read the contents of a file asynchronously without blocking the event loop.
-
-    This implementation uses thread pool execution to avoid blocking during file I/O,
-    allowing true parallel execution of multiple file reads.
-
-    Args:
-        filepath: The path to the file to read.
-
-    Returns:
-        str: The contents of the file or an error message.
-    """
-    tool = AsyncReadFileTool(None)  # No UI for pydantic-ai compatibility
-    try:
-        return await tool.execute(filepath)
-    except ToolExecutionError as e:
-        # Return error message for pydantic-ai compatibility
-        return str(e)
-
-
-# Benchmarking utilities for testing
-async def benchmark_read_performance():
-    """Benchmark the performance difference between sync and async reads."""
-    import contextlib
-    import tempfile
-    import time
-
-    from tunacode.tools.read_file import read_file as read_file_sync
-
-    # Create some test files using tempfile for secure temporary file creation
-    test_files = []
-    for _ in range(10):
-        with tempfile.NamedTemporaryFile(mode="w", delete=False, suffix=".txt") as temp_file:
-            temp_file.write("x" * 10000)  # 10KB file
-            test_files.append(temp_file.name)
-
-    # Test synchronous reads (sequential)
-    start_time = time.time()
-    for filepath in test_files:
-        await read_file_sync(filepath)
-    sync_time = time.time() - start_time
-
-    # Test async reads (parallel)
-    start_time = time.time()
-    tasks = [read_file_async(filepath) for filepath in test_files]
-    await asyncio.gather(*tasks)
-    async_time = time.time() - start_time
-
-    # Cleanup using safe file removal
-    for filepath in test_files:
-        with contextlib.suppress(OSError):
-            os.unlink(filepath)
-
-    print(f"Synchronous reads: {sync_time:.3f}s")
-    print(f"Async reads: {async_time:.3f}s")
-    print(f"Speedup: {sync_time / async_time:.2f}x")
-
-
-if __name__ == "__main__":
-    # Run benchmark when executed directly
-    asyncio.run(benchmark_read_performance())

tunacode/tools/todo.py

@@ -1,349 +0,0 @@
-"""Todo management tool for agent integration.
-
-This tool allows the AI agent to manage todo items during task execution.
-It provides functionality for creating, updating, and tracking tasks.
-"""
-
-import uuid
-from datetime import datetime
-from typing import List, Literal, Optional, Union
-
-from pydantic_ai.exceptions import ModelRetry
-
-from tunacode.constants import (
-    MAX_TODO_CONTENT_LENGTH,
-    MAX_TODOS_PER_SESSION,
-    TODO_PRIORITIES,
-    TodoPriority,
-    TodoStatus,
-)
-from tunacode.types import TodoItem, ToolResult, UILogger
-
-from .base import BaseTool
-
-
-class TodoTool(BaseTool):
-    """Tool for managing todo items from the AI agent."""
-
-    def __init__(self, state_manager, ui_logger: UILogger | None = None):
-        """Initialize the todo tool.
-
-        Args:
-            state_manager: StateManager instance for accessing todos
-            ui_logger: UI logger instance for displaying messages
-        """
-        super().__init__(ui_logger)
-        self.state_manager = state_manager
-
-    @property
-    def tool_name(self) -> str:
-        return "todo"
-
-    async def _execute(
-        self,
-        action: Literal["add", "add_multiple", "update", "complete", "list", "remove"],
-        content: Optional[Union[str, List[str]]] = None,
-        todo_id: Optional[str] = None,
-        status: Optional[Literal["pending", "in_progress", "completed"]] = None,
-        priority: Optional[Literal["high", "medium", "low"]] = None,
-        todos: Optional[List[dict]] = None,
-    ) -> ToolResult:
-        """Execute todo management actions.
-
-        Args:
-            action: The action to perform (add, add_multiple, update, complete, list, remove)
-            content: Content for new todos or updates (can be string or list for add_multiple)
-            todo_id: ID of existing todo for updates/completion
-            status: Status to set for updates
-            priority: Priority to set for new/updated todos
-            todos: List of todo dictionaries for add_multiple action (format: [{"content": "...", "priority": "..."}])
-
-        Returns:
-            str: Result message describing what was done
-
-        Raises:
-            ModelRetry: When invalid parameters are provided
-        """
-        if action == "add":
-            if isinstance(content, list):
-                raise ModelRetry("Use 'add_multiple' action for adding multiple todos")
-            return await self._add_todo(content, priority)
-        elif action == "add_multiple":
-            return await self._add_multiple_todos(content, todos, priority)
-        elif action == "update":
-            if isinstance(content, list):
-                raise ModelRetry("Cannot update with list content")
-            return await self._update_todo(todo_id, status, priority, content)
-        elif action == "complete":
-            return await self._complete_todo(todo_id)
-        elif action == "list":
-            return await self._list_todos()
-        elif action == "remove":
-            return await self._remove_todo(todo_id)
-        else:
-            raise ModelRetry(
-                f"Invalid action '{action}'. Must be one of: add, add_multiple, update, complete, list, remove"
-            )
-
-    async def _add_todo(self, content: Optional[str], priority: Optional[str]) -> ToolResult:
-        """Add a new todo item."""
-        if not content:
-            raise ModelRetry("Content is required when adding a todo")
-
-        # Validate content length
-        if len(content) > MAX_TODO_CONTENT_LENGTH:
-            raise ModelRetry(
-                f"Todo content is too long. Maximum length is {MAX_TODO_CONTENT_LENGTH} characters"
-            )
-
-        # Check todo limit
-        if len(self.state_manager.session.todos) >= MAX_TODOS_PER_SESSION:
-            raise ModelRetry(
-                f"Cannot add more todos. Maximum of {MAX_TODOS_PER_SESSION} todos allowed per session"
-            )
-
-        # Generate UUID for guaranteed uniqueness
-        new_id = f"todo_{uuid.uuid4().hex[:8]}"
-
-        # Default priority if not specified
-        todo_priority = priority or TodoPriority.MEDIUM
-        if todo_priority not in [p.value for p in TodoPriority]:
-            raise ModelRetry(
-                f"Invalid priority '{todo_priority}'. Must be one of: {', '.join([p.value for p in TodoPriority])}"
-            )
-
-        new_todo = TodoItem(
-            id=new_id,
-            content=content,
-            status=TodoStatus.PENDING,
-            priority=todo_priority,
-            created_at=datetime.now(),
-        )
-
-        self.state_manager.add_todo(new_todo)
-        return f"Added todo {new_id}: {content} (priority: {todo_priority})"
-
-    async def _add_multiple_todos(
-        self,
-        content: Optional[Union[str, List[str]]],
-        todos: Optional[List[dict]],
-        priority: Optional[str],
-    ) -> ToolResult:
-        """Add multiple todo items at once."""
-
-        # Handle different input formats
-        todos_to_add = []
-
-        if todos:
-            # Structured format: [{"content": "...", "priority": "..."}, ...]
-            for todo_data in todos:
-                if not isinstance(todo_data, dict) or "content" not in todo_data:
-                    raise ModelRetry("Each todo must be a dict with 'content' field")
-                todo_content = todo_data["content"]
-                todo_priority = todo_data.get("priority", priority or TodoPriority.MEDIUM)
-                if todo_priority not in TODO_PRIORITIES:
-                    raise ModelRetry(
-                        f"Invalid priority '{todo_priority}'. Must be one of: {', '.join(TODO_PRIORITIES)}"
-                    )
-                todos_to_add.append((todo_content, todo_priority))
-        elif isinstance(content, list):
-            # List of strings format: ["task1", "task2", ...]
-            default_priority = priority or TodoPriority.MEDIUM
-            if default_priority not in TODO_PRIORITIES:
-                raise ModelRetry(
-                    f"Invalid priority '{default_priority}'. Must be one of: {', '.join(TODO_PRIORITIES)}"
-                )
-            for task_content in content:
-                if not isinstance(task_content, str):
-                    raise ModelRetry("All content items must be strings")
-                todos_to_add.append((task_content, default_priority))
-        else:
-            raise ModelRetry(
-                "For add_multiple, provide either 'todos' list or 'content' as list of strings"
-            )
-
-        if not todos_to_add:
-            raise ModelRetry("No todos to add")
-
-        # Check todo limit
-        current_count = len(self.state_manager.session.todos)
-        if current_count + len(todos_to_add) > MAX_TODOS_PER_SESSION:
-            available = MAX_TODOS_PER_SESSION - current_count
-            raise ModelRetry(
-                f"Cannot add {len(todos_to_add)} todos. Only {available} slots available (max {MAX_TODOS_PER_SESSION} per session)"
-            )
-
-        # Add all todos
-        added_ids = []
-        for task_content, task_priority in todos_to_add:
-            # Validate content length
-            if len(task_content) > MAX_TODO_CONTENT_LENGTH:
-                raise ModelRetry(
-                    f"Todo content is too long: '{task_content[:50]}...'. Maximum length is {MAX_TODO_CONTENT_LENGTH} characters"
-                )
-
-            # Generate UUID for guaranteed uniqueness
-            new_id = f"todo_{uuid.uuid4().hex[:8]}"
-
-            new_todo = TodoItem(
-                id=new_id,
-                content=task_content,
-                status=TodoStatus.PENDING,
-                priority=task_priority,
-                created_at=datetime.now(),
-            )
-
-            self.state_manager.add_todo(new_todo)
-            added_ids.append(new_id)
-
-        count = len(added_ids)
-        return f"Added {count} todos (IDs: {', '.join(added_ids)})"
-
-    async def _update_todo(
-        self,
-        todo_id: Optional[str],
-        status: Optional[str],
-        priority: Optional[str],
-        content: Optional[str],
-    ) -> ToolResult:
-        """Update an existing todo item."""
-        if not todo_id:
-            raise ModelRetry("Todo ID is required for updates")
-
-        # Find the todo
-        todo = None
-        for t in self.state_manager.session.todos:
-            if t.id == todo_id:
-                todo = t
-                break
-
-        if not todo:
-            raise ModelRetry(f"Todo with ID '{todo_id}' not found")
-
-        changes = []
-
-        # Update status if provided
-        if status:
-            if status not in [s.value for s in TodoStatus]:
-                raise ModelRetry(
-                    f"Invalid status '{status}'. Must be one of: {', '.join([s.value for s in TodoStatus])}"
-                )
-            todo.status = status
-            if status == TodoStatus.COMPLETED.value and not todo.completed_at:
-                todo.completed_at = datetime.now()
-            changes.append(f"status to {status}")
-
-        # Update priority if provided
-        if priority:
-            if priority not in [p.value for p in TodoPriority]:
-                raise ModelRetry(
-                    f"Invalid priority '{priority}'. Must be one of: {', '.join([p.value for p in TodoPriority])}"
-                )
-            todo.priority = priority
-            changes.append(f"priority to {priority}")
-
-        # Update content if provided
-        if content:
-            todo.content = content
-            changes.append(f"content to '{content}'")
-
-        if not changes:
-            raise ModelRetry(
-                "At least one of status, priority, or content must be provided for updates"
-            )
-
-        change_summary = ", ".join(changes)
-        return f"Updated todo {todo_id}: {change_summary}"
-
-    async def _complete_todo(self, todo_id: Optional[str]) -> ToolResult:
-        """Mark a todo as completed."""
-        if not todo_id:
-            raise ModelRetry("Todo ID is required to mark as complete")
-
-        # Find and update the todo
-        for todo in self.state_manager.session.todos:
-            if todo.id == todo_id:
-                todo.status = TodoStatus.COMPLETED.value
-                todo.completed_at = datetime.now()
-                return f"Marked todo {todo_id} as completed: {todo.content}"
-
-        raise ModelRetry(f"Todo with ID '{todo_id}' not found")
-
-    async def _list_todos(self) -> ToolResult:
-        """List all current todos."""
-        todos = self.state_manager.session.todos
-        if not todos:
-            return "No todos found"
-
-        # Group by status for better organization
-        pending = [t for t in todos if t.status == TodoStatus.PENDING.value]
-        in_progress = [t for t in todos if t.status == TodoStatus.IN_PROGRESS.value]
-        completed = [t for t in todos if t.status == TodoStatus.COMPLETED.value]
-
-        lines = []
-
-        if in_progress:
-            lines.append("IN PROGRESS:")
-            for todo in in_progress:
-                lines.append(f"  {todo.id}: {todo.content} (priority: {todo.priority})")
-
-        if pending:
-            lines.append("\nPENDING:")
-            for todo in pending:
-                lines.append(f"  {todo.id}: {todo.content} (priority: {todo.priority})")
-
-        if completed:
-            lines.append("\nCOMPLETED:")
-            for todo in completed:
-                lines.append(f"  {todo.id}: {todo.content}")
-
-        return "\n".join(lines)
-
-    async def _remove_todo(self, todo_id: Optional[str]) -> ToolResult:
-        """Remove a todo item."""
-        if not todo_id:
-            raise ModelRetry("Todo ID is required to remove a todo")
-
-        # Find the todo first to get its content for the response
-        todo_content = None
-        for todo in self.state_manager.session.todos:
-            if todo.id == todo_id:
-                todo_content = todo.content
-                break
-
-        if not todo_content:
-            raise ModelRetry(f"Todo with ID '{todo_id}' not found")
-
-        self.state_manager.remove_todo(todo_id)
-        return f"Removed todo {todo_id}: {todo_content}"
-
-    def get_current_todos_sync(self) -> str:
-        """Get current todos synchronously for system prompt inclusion."""
-        todos = self.state_manager.session.todos
-
-        if not todos:
-            return "No todos found"
-
-        # Group by status for better organization
-        pending = [t for t in todos if t.status == TodoStatus.PENDING.value]
-        in_progress = [t for t in todos if t.status == TodoStatus.IN_PROGRESS.value]
-        completed = [t for t in todos if t.status == TodoStatus.COMPLETED.value]
-
-        lines = []
-
-        if in_progress:
-            lines.append("IN PROGRESS:")
-            for todo in in_progress:
-                lines.append(f"  {todo.id}: {todo.content} (priority: {todo.priority})")
-
-        if pending:
-            lines.append("\nPENDING:")
-            for todo in pending:
-                lines.append(f"  {todo.id}: {todo.content} (priority: {todo.priority})")
-
-        if completed:
-            lines.append("\nCOMPLETED:")
-            for todo in completed:
-                lines.append(f"  {todo.id}: {todo.content}")
-
-        return "\n".join(lines)