tunacode-cli 0.0.30__py3-none-any.whl → 0.0.32__py3-none-any.whl

tunacode/tools/read_file.py

@@ -5,6 +5,7 @@ File reading tool for agent operations in the TunaCode application.
 Provides safe file reading with size limits and proper error handling.
 """
 
+import asyncio
 import os
 
 from tunacode.constants import (ERROR_FILE_DECODE, ERROR_FILE_DECODE_DETAILS, ERROR_FILE_NOT_FOUND,
@@ -40,9 +41,14 @@ class ReadFileTool(FileBasedTool):
                 await self.ui.error(err_msg)
             raise ToolExecutionError(tool_name=self.tool_name, message=err_msg, original_error=None)
 
-        with open(filepath, "r", encoding="utf-8") as file:
-            content = file.read()
-            return content
+        # Run the blocking file I/O in a separate thread to avoid blocking the event loop
+        def _read_sync(path: str) -> str:
+            """Synchronous helper to read file contents (runs in thread)."""
+            with open(path, "r", encoding="utf-8") as f:
+                return f.read()
+
+        content: str = await asyncio.to_thread(_read_sync, filepath)
+        return content
 
     async def _handle_error(self, error: Exception, filepath: str = None) -> ToolResult:
         """Handle errors with specific messages for common cases.

tunacode/tools/read_file_async_poc.py

@@ -0,0 +1,188 @@
+"""
+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 time
+
+    from tunacode.tools.read_file import read_file as read_file_sync
+
+    # Create some test files
+    test_files = []
+    for i in range(10):
+        filepath = f"/tmp/test_file_{i}.txt"
+        with open(filepath, "w") as f:
+            f.write("x" * 10000)  # 10KB file
+        test_files.append(filepath)
+
+    # 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
+    for filepath in test_files:
+        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_cli-0.0.30.dist-info → tunacode_cli-0.0.32.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tunacode-cli
-Version: 0.0.30
+Version: 0.0.32
 Summary: Your agentic CLI developer.
 Author-email: larock22 <noreply@github.com>
 License-Expression: MIT
@@ -31,6 +31,7 @@ Requires-Dist: flake8; extra == "dev"
 Requires-Dist: isort; extra == "dev"
 Requires-Dist: pytest; extra == "dev"
 Requires-Dist: pytest-cov; extra == "dev"
+Requires-Dist: pytest-asyncio; extra == "dev"
 Requires-Dist: textual-dev; extra == "dev"
 Dynamic: license-file
 
@@ -44,7 +45,7 @@ Dynamic: license-file
 
 **AI-powered CLI coding assistant**
 
-![Demo](demo.gif)
+![Demo](docs/assets/demo.gif)
 
 </div>
 
@@ -75,7 +76,7 @@ tunacode --model "anthropic:claude-3.5-sonnet" --key "sk-ant-your-anthropic-key"
 tunacode --model "openrouter:openai/gpt-4o" --key "sk-or-your-openrouter-key"
 ```
 
-Your config is saved to `~/.config/tunacode.json`
+Your config is saved to `~/.config/tunacode.json` (edit directly with `nvim ~/.config/tunacode.json`)
 
 ## Start Coding
 
@@ -96,6 +97,14 @@ tunacode
 | `!<command>` | Run shell command |
 | `exit` | Exit TunaCode |
 
+## Performance
+
+TunaCode leverages parallel execution for read-only operations, achieving **3x faster** file operations:
+
+![Parallel Execution Performance](docs/assets/parrelel_work_3x.png)
+
+Multiple file reads, directory listings, and searches execute concurrently using async I/O, making code exploration significantly faster.
+
 ## Safety First
 
 ⚠️ **Important**: TunaCode can modify your codebase. Always:
@@ -105,10 +114,10 @@ tunacode
 
 ## Documentation
 
-- [**Features**](documentation/FEATURES.md) - All features, tools, and commands
-- [**Advanced Configuration**](documentation/ADVANCED-CONFIG.md) - Provider setup, MCP, customization
-- [**Architecture**](documentation/ARCHITECTURE.md) - Source code organization and design
-- [**Development**](documentation/DEVELOPMENT.md) - Contributing and development setup
+- [**Features**](docs/FEATURES.md) - All features, tools, and commands
+- [**Advanced Configuration**](docs/ADVANCED-CONFIG.md) - Provider setup, MCP, customization
+- [**Architecture**](docs/ARCHITECTURE.md) - Source code organization and design
+- [**Development**](docs/DEVELOPMENT.md) - Contributing and development setup
 
 ## Links
 

{tunacode_cli-0.0.30.dist-info → tunacode_cli-0.0.32.dist-info}/RECORD

@@ -1,14 +1,16 @@
+api/auth.py,sha256=_ysF1RCXvtJR1S35lbYQZexES1lif4J6VVzEyqNK74Q,303
+api/users.py,sha256=WRcy1Vsr4cEC8CW2qeN3XrA9EMyIk47ufpMyvQ4nLuw,193
 tunacode/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tunacode/constants.py,sha256=HIOHsN-zQoS2IKwYDGEQVXduAb2IFx_fVdlzRJSxVS8,3799
+tunacode/constants.py,sha256=HQGb-0hAm65zPpwvAmYoDMW-Ye_iMny4mNpeAxab_xU,4074
 tunacode/context.py,sha256=6sterdRvPOyG3LU0nEAXpBsEPZbO3qtPyTlJBi-_VXE,2612
-tunacode/exceptions.py,sha256=_Dyj6cC0868dMABekdQHXCg5XhucJumbGUMXaSDzgB4,2645
+tunacode/exceptions.py,sha256=mTWXuWyr1k16CGLWN2tsthDGi7lbx1JK0ekIqogYDP8,3105
 tunacode/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tunacode/setup.py,sha256=dYn0NeAxtNIDSogWEmGSyjb9wsr8AonZ8vAo5sw9NIw,1909
 tunacode/types.py,sha256=BciT-uxnQ44iC-4QiDY72OD23LOtqSyMOuK_N0ttlaA,7676
 tunacode/cli/__init__.py,sha256=zgs0UbAck8hfvhYsWhWOfBe5oK09ug2De1r4RuQZREA,55
-tunacode/cli/commands.py,sha256=aRdgjccMwlLXolR8gzW82KpKnMs5MjfN2McYQ4z7r0Y,34142
+tunacode/cli/commands.py,sha256=w1bqLuxkKoavvXrpARFi5qg3yfYx_MA-1COyPj9RJGw,29884
 tunacode/cli/main.py,sha256=PIcFnfmIoI_pmK2y-zB_ouJbzR5fbSI7zsKQNPB_J8o,2406
-tunacode/cli/repl.py,sha256=l-RxQ3aVbdaELvbK7bvBVKBhYwoxof95y3AVhgGReVI,15685
+tunacode/cli/repl.py,sha256=AYVU-k8yKa8LjJg3s3vu5LrHyMUIShtgUlyakwb-rh4,13583
 tunacode/cli/textual_app.py,sha256=14-Nt0IIETmyHBrNn9uwSF3EwCcutwTp6gdoKgNm0sY,12593
 tunacode/cli/textual_bridge.py,sha256=LvqiTtF0hu3gNujzpKaW9h-m6xzEP3OH2M8KL2pCwRc,6333
 tunacode/configuration/__init__.py,sha256=MbVXy8bGu0yKehzgdgZ_mfWlYGvIdb1dY2Ly75nfuPE,17
@@ -16,32 +18,32 @@ tunacode/configuration/defaults.py,sha256=oLgmHprB3cTaFvT9dn_rgg206zoj09GRXRbI7M
 tunacode/configuration/models.py,sha256=XPobkLM_TzKTuMIWhK-svJfGRGFT9r2LhKEM6rv6QHk,3756
 tunacode/configuration/settings.py,sha256=lm2ov8rG1t4C5JIXMOhIKik5FAsjpuLVYtFmnE1ZQ3k,995
 tunacode/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tunacode/core/code_index.py,sha256=jgAx3lSWP_DwnyiP5Jkm1YvX4JJyI4teMzlNrJSpEOA,15661
 tunacode/core/state.py,sha256=PHGCGjx_X03I5jO-T1JkREQm4cwYEXQty59JJlnk24c,1608
-tunacode/core/tool_handler.py,sha256=OKx7jM8pml6pSEnoARu33_uBY8awJBqvhbVeBn6T4ow,1804
-tunacode/core/agents/__init__.py,sha256=TiXwymGRNMuOqQaRLpNCAt7bZArg8rkadIRs4Nw21SQ,275
-tunacode/core/agents/main.py,sha256=PwfGaQoWE1L-ySSAmEQXl-CTWsNVrlYw9UhaVRoFqs8,25930
-tunacode/core/agents/orchestrator.py,sha256=SSJyd4O_WZzcI5zygoUx1nhzRpfT6DrPsp2XtK2UVzY,8607
-tunacode/core/agents/planner_schema.py,sha256=pu2ehQVALjiJ5HJD7EN6xuZHCknsrXO9z0xHuVdlKW8,345
-tunacode/core/agents/readonly.py,sha256=jOG3CF5G1y9k4sBn7ChXN1GXWbmB_0pFGcaMMI4iaLs,2325
+tunacode/core/tool_handler.py,sha256=BPjR013OOO0cLXPdLeL2FDK0ixUwOYu59FfHdcdFhp4,2277
+tunacode/core/agents/__init__.py,sha256=UUJiPYb91arwziSpjd7vIk7XNGA_4HQbsOIbskSqevA,149
+tunacode/core/agents/main.py,sha256=HuDVLFp18MWONjrAtAPZgigVpAGB8KmbA-Idx0ElAQs,37736
 tunacode/core/background/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tunacode/core/background/manager.py,sha256=rJdl3eDLTQwjbT7VhxXcJbZopCNR3M8ZGMbmeVnwwMc,1126
 tunacode/core/llm/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tunacode/core/llm/planner.py,sha256=G1oxRFynYisWspcWr6KvVuiWHmElozhhVds6Wj4yrLk,2111
 tunacode/core/setup/__init__.py,sha256=lzdpY6rIGf9DDlDBDGFvQZaSOQeFsNglHbkpq1-GtU8,376
 tunacode/core/setup/agent_setup.py,sha256=trELO8cPnWo36BBnYmXDEnDPdhBg0p-VLnx9A8hSSSQ,1401
 tunacode/core/setup/base.py,sha256=cbyT2-xK2mWgH4EO17VfM_OM2bj0kT895NW2jSXbe3c,968
 tunacode/core/setup/config_setup.py,sha256=A1MEbkZq2FvVg9FNlLD9_JO_vlr0ixP-6Ay0-2W7VvQ,14330
 tunacode/core/setup/coordinator.py,sha256=oVTN2xIeJERXitVJpkIk9tDGLs1D1bxIRmaogJwZJFI,2049
 tunacode/core/setup/environment_setup.py,sha256=n3IrObKEynHZSwtUJ1FddMg2C4sHz7ca42awemImV8s,2225
-tunacode/core/setup/git_safety_setup.py,sha256=T7hwIf3u3Tq3QtIdUAfuHI6vclMfm2Sqcml5l6x02oA,6799
-tunacode/prompts/system.md,sha256=6c3UA4-Fj6hJssZD2O7DOjOcMcvYzwc2TvUXzMBKJTU,5305
+tunacode/core/setup/git_safety_setup.py,sha256=CRIqrQt0QUJQRS344njty_iCqTorrDhHlXRuET7w0Tk,6714
+tunacode/prompts/system.md,sha256=qnTXKEVsQY7o54B2kFNsdkbbCHhxdqVXytUQbhKy7PM,12027
 tunacode/services/__init__.py,sha256=w_E8QK6RnvKSvU866eDe8BCRV26rAm4d3R-Yg06OWCU,19
 tunacode/services/mcp.py,sha256=R48X73KQjQ9vwhBrtbWHSBl-4K99QXmbIhh5J_1Gezo,3046
 tunacode/tools/__init__.py,sha256=ECBuUWWF1JjHW42CCceaPKgVTQyuljbz3RlhuA2fe2s,314
 tunacode/tools/base.py,sha256=TF71ZE66-W-7GLY8QcPpPJ5CVjod6FHL1caBOTCssvU,7044
 tunacode/tools/bash.py,sha256=mgZqugfDFevZ4BETuUv90pzXvtq7qKGUGFiuDxzmytk,8766
-tunacode/tools/grep.py,sha256=N0Iu5MuSAVGBueu6PoE4Pt1x3oMIlX5aaZyejQwTlU8,26492
-tunacode/tools/read_file.py,sha256=Cz1-7sdQwOdaqkVvkVpORiBdNtncCVlP9e9cu37ya80,2988
+tunacode/tools/glob.py,sha256=TSgVK79ewZgGw8ucYkkiHgVqRgkw-wZrhP8j52nm_gQ,10334
+tunacode/tools/grep.py,sha256=jboEVA2ATv0YI8zg9dF89emZ_HWy2vVtsQ_-hDhlr7g,26337
+tunacode/tools/list_dir.py,sha256=1kNqzYCNlcA5rqXIEVqcjQy6QxlLZLj5AG6YIECfwio,7217
+tunacode/tools/read_file.py,sha256=BqHxPspZBYotz5wtjuP-zve61obsx98z5TU-aw5BJHg,3273
+tunacode/tools/read_file_async_poc.py,sha256=0rSfYCmoNcvWk8hB1z86l32-tomSc9yOM4tR4nrty_o,6267
 tunacode/tools/run_command.py,sha256=kYg_Re397OmZdKtUSjpNfYYNDBjd0vsS1xMK0yP181I,3776
 tunacode/tools/update_file.py,sha256=bW1MhTzRjBDjJzqQ6A1yCVEbkr1oIqtEC8uqcg_rfY4,3957
 tunacode/tools/write_file.py,sha256=prL6u8XOi9ZyPU-YNlG9YMLbSLrDJXDRuDX73ncXh-k,2699
@@ -68,9 +70,9 @@ tunacode/utils/system.py,sha256=FSoibTIH0eybs4oNzbYyufIiV6gb77QaeY2yGqW39AY,1138
 tunacode/utils/text_utils.py,sha256=zRBaorvtyd7HBEWtIfCH1Wce1L6rhsQwpORUEGBFMjA,2981
 tunacode/utils/token_counter.py,sha256=nGCWwrHHFbKywqeDCEuJnADCkfJuzysWiB6cCltJOKI,648
 tunacode/utils/user_configuration.py,sha256=IGvUH37wWtZ4M5xpukZEWYhtuKKyKcl6DaeObGXdleU,2610
-tunacode_cli-0.0.30.dist-info/licenses/LICENSE,sha256=Btzdu2kIoMbdSp6OyCLupB1aRgpTCJ_szMimgEnpkkE,1056
-tunacode_cli-0.0.30.dist-info/METADATA,sha256=U4Dp9WTk0FRjr7d3fs7c_EKKWUAjC8jP5jfVXeOeVng,3619
-tunacode_cli-0.0.30.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-tunacode_cli-0.0.30.dist-info/entry_points.txt,sha256=hbkytikj4dGu6rizPuAd_DGUPBGF191RTnhr9wdhORY,51
-tunacode_cli-0.0.30.dist-info/top_level.txt,sha256=lKy2P6BWNi5XSA4DHFvyjQ14V26lDZctwdmhEJrxQbU,9
-tunacode_cli-0.0.30.dist-info/RECORD,,
+tunacode_cli-0.0.32.dist-info/licenses/LICENSE,sha256=Btzdu2kIoMbdSp6OyCLupB1aRgpTCJ_szMimgEnpkkE,1056
+tunacode_cli-0.0.32.dist-info/METADATA,sha256=uX02OQdTT5lrmAm6XFSO1IKEmv9uw9lkG1UGaVOcbcU,4023
+tunacode_cli-0.0.32.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+tunacode_cli-0.0.32.dist-info/entry_points.txt,sha256=hbkytikj4dGu6rizPuAd_DGUPBGF191RTnhr9wdhORY,51
+tunacode_cli-0.0.32.dist-info/top_level.txt,sha256=GuU751acRvOhM5yLKFW0-gBg62JGh5zycDSq4tRFOYE,13
+tunacode_cli-0.0.32.dist-info/RECORD,,

{tunacode_cli-0.0.30.dist-info → tunacode_cli-0.0.32.dist-info}/top_level.txt

@@ -1 +1,2 @@
+api
 tunacode

tunacode/core/agents/orchestrator.py

@@ -1,213 +0,0 @@
-"""Agent orchestration scaffolding.
-
-This module defines an ``OrchestratorAgent`` class that demonstrates how
-higher level planning and delegation could be layered on top of the existing
-``process_request`` workflow.  The goal is to keep orchestration logic isolated
-from the core agent implementation while reusing all current tooling and state
-handling provided by ``main.process_request``.
-"""
-
-from __future__ import annotations
-
-import asyncio
-import itertools
-from typing import List
-
-from ...types import AgentRun, FallbackResponse, ModelName, ResponseState
-from ..llm.planner import make_plan
-from ..state import StateManager
-from . import main as agent_main
-from .planner_schema import Task
-from .readonly import ReadOnlyAgent
-
-
-class OrchestratorAgent:
-    """Plan and run a sequence of sub-agent tasks."""
-
-    def __init__(self, state_manager: StateManager):
-        self.state = state_manager
-
-    async def plan(self, request: str, model: ModelName) -> List[Task]:
-        """Plan tasks for a user request using the planner LLM."""
-
-        return await make_plan(request, model, self.state)
-
-    async def _run_sub_task(self, task: Task, model: ModelName) -> AgentRun:
-        """Execute a single task using an appropriate sub-agent."""
-        from rich.console import Console
-
-        console = Console()
-
-        # Show which task is being executed
-        task_type = "WRITE" if task.mutate else "READ"
-        console.print(f"\n[dim][Task {task.id}] {task_type}[/dim]")
-        console.print(f"[dim]  → {task.description}[/dim]")
-
-        if task.mutate:
-            agent_main.get_or_create_agent(model, self.state)
-            result = await agent_main.process_request(model, task.description, self.state)
-        else:
-            agent = ReadOnlyAgent(model, self.state)
-            result = await agent.process_request(task.description)
-
-        console.print(f"[dim][Task {task.id}] Complete[/dim]")
-        return result
-
-    async def run(self, request: str, model: ModelName | None = None) -> List[AgentRun]:
-        """Plan and execute a user request.
-
-        Parameters
-        ----------
-        request:
-            The high level user request to process.
-        model:
-            Optional model name to use for sub agents.  Defaults to the current
-            session model.
-        """
-        from rich.console import Console
-
-        console = Console()
-        model = model or self.state.session.current_model
-
-        # Track response state across all sub-tasks
-        response_state = ResponseState()
-
-        # Show orchestrator is starting
-        console.print(
-            "\n[cyan]Orchestrator Mode: Analyzing request and creating execution plan...[/cyan]"
-        )
-
-        tasks = await self.plan(request, model)
-
-        # Show execution is starting
-        console.print(f"\n[cyan]Executing plan with {len(tasks)} tasks...[/cyan]")
-
-        results: List[AgentRun] = []
-        task_progress = []
-
-        for mutate_flag, group in itertools.groupby(tasks, key=lambda t: t.mutate):
-            if mutate_flag:
-                for t in group:
-                    result = await self._run_sub_task(t, model)
-                    results.append(result)
-
-                    # Track task progress
-                    task_progress.append(
-                        {
-                            "task": t,
-                            "completed": True,
-                            "had_output": hasattr(result, "result")
-                            and result.result
-                            and getattr(result.result, "output", None),
-                        }
-                    )
-
-                    # Check if this task produced user-visible output
-                    if hasattr(result, "response_state"):
-                        response_state.has_user_response |= result.response_state.has_user_response
-            else:
-                # Show parallel execution
-                task_list = list(group)
-                if len(task_list) > 1:
-                    console.print(
-                        f"\n[dim][Parallel Execution] Running {len(task_list)} read-only tasks concurrently...[/dim]"
-                    )
-                coros = [self._run_sub_task(t, model) for t in task_list]
-                parallel_results = await asyncio.gather(*coros)
-                results.extend(parallel_results)
-
-                # Track parallel task progress
-                for t, result in zip(task_list, parallel_results):
-                    task_progress.append(
-                        {
-                            "task": t,
-                            "completed": True,
-                            "had_output": hasattr(result, "result")
-                            and result.result
-                            and getattr(result.result, "output", None),
-                        }
-                    )
-
-                    # Check if this task produced user-visible output
-                    if hasattr(result, "response_state"):
-                        response_state.has_user_response |= result.response_state.has_user_response
-
-        console.print("\n[green]Orchestrator completed all tasks successfully![/green]")
-
-        # Check if we need a fallback response
-        has_any_output = any(
-            hasattr(r, "result") and r.result and getattr(r.result, "output", None) for r in results
-        )
-
-        fallback_enabled = self.state.session.user_config.get("settings", {}).get(
-            "fallback_response", True
-        )
-
-        # Use has_any_output as the primary check since response_state might not be set for all agents
-        if not has_any_output and fallback_enabled:
-            # Generate a detailed fallback response
-            completed_count = sum(1 for tp in task_progress if tp["completed"])
-            output_count = sum(1 for tp in task_progress if tp["had_output"])
-
-            fallback = FallbackResponse(
-                summary="Orchestrator completed all tasks but no final response was generated.",
-                progress=f"Executed {completed_count}/{len(tasks)} tasks successfully",
-            )
-
-            # Add task details based on verbosity
-            verbosity = self.state.session.user_config.get("settings", {}).get(
-                "fallback_verbosity", "normal"
-            )
-
-            if verbosity in ["normal", "detailed"]:
-                # List what was done
-                if task_progress:
-                    fallback.issues.append(f"Tasks executed: {completed_count}")
-                    if output_count == 0:
-                        fallback.issues.append("No tasks produced visible output")
-
-                    if verbosity == "detailed":
-                        # Add task descriptions
-                        for i, tp in enumerate(task_progress, 1):
-                            task_type = "WRITE" if tp["task"].mutate else "READ"
-                            status = "✓" if tp["completed"] else "✗"
-                            fallback.issues.append(
-                                f"{status} Task {i} [{task_type}]: {tp['task'].description}"
-                            )
-
-            # Suggest next steps
-            fallback.next_steps.append("Review the task execution above for any errors")
-            fallback.next_steps.append(
-                "Try running individual tasks separately for more detailed output"
-            )
-
-            # Create synthesized response
-            synthesis_parts = [fallback.summary, ""]
-
-            if fallback.progress:
-                synthesis_parts.append(f"Progress: {fallback.progress}")
-
-            if fallback.issues:
-                synthesis_parts.append("\nDetails:")
-                synthesis_parts.extend(f"  • {issue}" for issue in fallback.issues)
-
-            if fallback.next_steps:
-                synthesis_parts.append("\nNext steps:")
-                synthesis_parts.extend(f"  • {step}" for step in fallback.next_steps)
-
-            synthesis = "\n".join(synthesis_parts)
-
-            class FallbackResult:
-                def __init__(self, output: str, response_state: ResponseState):
-                    self.output = output
-                    self.response_state = response_state
-
-            class FallbackRun:
-                def __init__(self, synthesis: str, response_state: ResponseState):
-                    self.result = FallbackResult(synthesis, response_state)
-                    self.response_state = response_state
-
-            response_state.has_final_synthesis = True
-            results.append(FallbackRun(synthesis, response_state))
-
-        return results

tunacode/core/agents/planner_schema.py

@@ -1,9 +0,0 @@
-from pydantic import BaseModel, Field
-
-
-class Task(BaseModel):
-    """Single sub-task generated by the planner."""
-
-    id: int = Field(..., description="1-based task index in execution order")
-    description: str = Field(..., description="What the sub-agent must do")
-    mutate: bool = Field(..., description="True if the task changes code")

tunacode/core/agents/readonly.py

@@ -1,65 +0,0 @@
-"""Read-only agent implementation for non-mutating operations."""
-
-from __future__ import annotations
-
-from typing import TYPE_CHECKING
-
-from ...tools.grep import grep
-from ...tools.read_file import read_file
-from ...types import AgentRun, ModelName, ResponseState
-from ..state import StateManager
-
-if TYPE_CHECKING:
-    from ...types import PydanticAgent
-
-
-class ReadOnlyAgent:
-    """Agent configured with read-only tools for analysis tasks."""
-
-    def __init__(self, model: ModelName, state_manager: StateManager):
-        self.model = model
-        self.state_manager = state_manager
-        self._agent: PydanticAgent | None = None
-
-    def _get_agent(self) -> PydanticAgent:
-        """Lazily create the agent with read-only tools."""
-        if self._agent is None:
-            from .main import get_agent_tool
-
-            Agent, Tool = get_agent_tool()
-
-            # Create agent with only read-only tools
-            self._agent = Agent(
-                model=self.model,
-                system_prompt="You are a read-only assistant. You can analyze and read files but cannot modify them.",
-                tools=[
-                    Tool(read_file),
-                    Tool(grep),
-                ],
-            )
-        return self._agent
-
-    async def process_request(self, request: str) -> AgentRun:
-        """Process a request using only read-only tools."""
-        agent = self._get_agent()
-        response_state = ResponseState()
-
-        # Use iter() like main.py does to get the full run context
-        async with agent.iter(request) as agent_run:
-            async for node in agent_run:
-                # Check if this node produced user-visible output
-                if hasattr(node, "result") and node.result and hasattr(node.result, "output"):
-                    if node.result.output:
-                        response_state.has_user_response = True
-
-        # Wrap the agent run to include response_state
-        class AgentRunWithState:
-            def __init__(self, wrapped_run):
-                self._wrapped = wrapped_run
-                self.response_state = response_state
-
-            def __getattr__(self, name):
-                # Delegate all other attributes to the wrapped object
-                return getattr(self._wrapped, name)
-
-        return AgentRunWithState(agent_run)