tunacode-cli 0.0.17__py3-none-any.whl → 0.0.19__py3-none-any.whl

tunacode/core/agents/main.py

@@ -9,8 +9,22 @@ import re
 from datetime import datetime, timezone
 from typing import Optional
 
-from pydantic_ai import Agent, Tool
-from pydantic_ai.messages import ModelRequest, ToolReturnPart
+# Lazy import for Agent and Tool
+
+
+def get_agent_tool():
+    import importlib
+
+    pydantic_ai = importlib.import_module("pydantic_ai")
+    return pydantic_ai.Agent, pydantic_ai.Tool
+
+
+def get_model_messages():
+    import importlib
+
+    messages = importlib.import_module("pydantic_ai.messages")
+    return messages.ModelRequest, messages.ToolReturnPart
+
 
 from tunacode.core.state import StateManager
 from tunacode.services.mcp import get_mcp_servers
@@ -20,15 +34,8 @@ from tunacode.tools.read_file import read_file
 from tunacode.tools.run_command import run_command
 from tunacode.tools.update_file import update_file
 from tunacode.tools.write_file import write_file
-from tunacode.types import (
-    AgentRun,
-    ErrorMessage,
-    ModelName,
-    PydanticAgent,
-    ToolCallback,
-    ToolCallId,
-    ToolName,
-)
+from tunacode.types import (AgentRun, ErrorMessage, ModelName, PydanticAgent, ToolCallback,
+                            ToolCallId, ToolName)
 
 
 async def _process_node(node, tool_callback: Optional[ToolCallback], state_manager: StateManager):
@@ -40,63 +47,65 @@ async def _process_node(node, tool_callback: Optional[ToolCallback], state_manag
         # Display thought immediately if show_thoughts is enabled
         if state_manager.session.show_thoughts:
             from tunacode.ui import console as ui
+
             await ui.muted(f"💭 THOUGHT: {node.thought}")
 
     if hasattr(node, "model_response"):
         state_manager.session.messages.append(node.model_response)
-        
+
         # Enhanced ReAct thought processing
         if state_manager.session.show_thoughts:
-            from tunacode.ui import console as ui
             import json
             import re
-            
+
+            from tunacode.ui import console as ui
+
             for part in node.model_response.parts:
-                if hasattr(part, 'content') and isinstance(part.content, str):
+                if hasattr(part, "content") and isinstance(part.content, str):
                     content = part.content.strip()
-                    
+
                     # Pattern 1: Inline JSON thoughts {"thought": "..."}
                     thought_pattern = r'\{"thought":\s*"([^"]+)"\}'
                     matches = re.findall(thought_pattern, content)
                     for thought in matches:
                         await ui.muted(f"💭 REASONING: {thought}")
-                        
+
                     # Pattern 2: Standalone thought JSON objects
                     try:
                         if content.startswith('{"thought"'):
                             thought_obj = json.loads(content)
-                            if 'thought' in thought_obj:
+                            if "thought" in thought_obj:
                                 await ui.muted(f"💭 REASONING: {thought_obj['thought']}")
                     except (json.JSONDecodeError, KeyError):
                         pass
-                    
+
                     # Pattern 3: Multi-line thoughts with context
                     multiline_pattern = r'\{"thought":\s*"([^"]+(?:\\.[^"]*)*?)"\}'
                     multiline_matches = re.findall(multiline_pattern, content, re.DOTALL)
                     for thought in multiline_matches:
                         if thought not in [m for m in matches]:  # Avoid duplicates
                             # Clean up escaped characters
-                            cleaned_thought = thought.replace('\\"', '"').replace('\\n', ' ')
+                            cleaned_thought = thought.replace('\\"', '"').replace("\\n", " ")
                             await ui.muted(f"💭 REASONING: {cleaned_thought}")
-                    
+
                     # Pattern 4: Text-based reasoning indicators
                     reasoning_indicators = [
-                        (r'I need to (.+?)\.', 'PLANNING'),
-                        (r'Let me (.+?)\.', 'ACTION'),
-                        (r'The output shows (.+?)\.', 'OBSERVATION'),
-                        (r'Based on (.+?), I should (.+?)\.', 'DECISION')
+                        (r"I need to (.+?)\.", "PLANNING"),
+                        (r"Let me (.+?)\.", "ACTION"),
+                        (r"The output shows (.+?)\.", "OBSERVATION"),
+                        (r"Based on (.+?), I should (.+?)\.", "DECISION"),
                     ]
-                    
+
                     for pattern, label in reasoning_indicators:
                         indicator_matches = re.findall(pattern, content, re.IGNORECASE)
                         for match in indicator_matches:
                             if isinstance(match, tuple):
-                                match_text = ' '.join(match)
+                                match_text = " ".join(match)
                             else:
                                 match_text = match
                             await ui.muted(f"🎯 {label}: {match_text}")
                             break  # Only show first match per pattern
-        
+
         # Check for tool calls and fallback to JSON parsing if needed
         has_tool_calls = False
         for part in node.model_response.parts:
@@ -106,28 +115,32 @@ async def _process_node(node, tool_callback: Optional[ToolCallback], state_manag
             elif part.part_kind == "tool-return":
                 obs_msg = f"OBSERVATION[{part.tool_name}]: {part.content[:2_000]}"
                 state_manager.session.messages.append(obs_msg)
-        
+
         # If no structured tool calls found, try parsing JSON from text content
         if not has_tool_calls and tool_callback:
             for part in node.model_response.parts:
-                if hasattr(part, 'content') and isinstance(part.content, str):
+                if hasattr(part, "content") and isinstance(part.content, str):
                     await extract_and_execute_tool_calls(part.content, tool_callback, state_manager)
 
 
 def get_or_create_agent(model: ModelName, state_manager: StateManager) -> PydanticAgent:
     if model not in state_manager.session.agents:
         max_retries = state_manager.session.user_config["settings"]["max_retries"]
-        
+
+        # Lazy import Agent and Tool
+        Agent, Tool = get_agent_tool()
+
         # Load system prompt
         import os
         from pathlib import Path
-        prompt_path = Path(__file__).parent.parent.parent / "prompts" / "system.txt"
+
+        prompt_path = Path(__file__).parent.parent.parent / "prompts" / "system.md"
         try:
             with open(prompt_path, "r", encoding="utf-8") as f:
                 system_prompt = f.read().strip()
         except FileNotFoundError:
             system_prompt = None
-        
+
         state_manager.session.agents[model] = Agent(
             model=model,
             system_prompt=system_prompt,
@@ -186,6 +199,8 @@ def patch_tool_messages(
     # Identify orphaned tools (those without responses and not being retried)
     for tool_call_id, tool_name in list(tool_calls.items()):
         if tool_call_id not in tool_returns and tool_call_id not in retry_prompts:
+            # Import ModelRequest and ToolReturnPart lazily
+            ModelRequest, ToolReturnPart = get_model_messages()
             messages.append(
                 ModelRequest(
                     parts=[
@@ -202,39 +217,41 @@ def patch_tool_messages(
             )
 
 
-async def parse_json_tool_calls(text: str, tool_callback: Optional[ToolCallback], state_manager: StateManager):
+async def parse_json_tool_calls(
+    text: str, tool_callback: Optional[ToolCallback], state_manager: StateManager
+):
     """
     Parse JSON tool calls from text when structured tool calling fails.
     Fallback for when API providers don't support proper tool calling.
     """
     if not tool_callback:
         return
-    
+
     # Pattern for JSON tool calls: {"tool": "tool_name", "args": {...}}
     # Find potential JSON objects and parse them
     potential_jsons = []
     brace_count = 0
     start_pos = -1
-    
+
     for i, char in enumerate(text):
-        if char == '{':
+        if char == "{":
             if brace_count == 0:
                 start_pos = i
             brace_count += 1
-        elif char == '}':
+        elif char == "}":
             brace_count -= 1
             if brace_count == 0 and start_pos != -1:
-                potential_json = text[start_pos:i+1]
+                potential_json = text[start_pos : i + 1]
                 try:
                     parsed = json.loads(potential_json)
-                    if isinstance(parsed, dict) and 'tool' in parsed and 'args' in parsed:
-                        potential_jsons.append((parsed['tool'], parsed['args']))
+                    if isinstance(parsed, dict) and "tool" in parsed and "args" in parsed:
+                        potential_jsons.append((parsed["tool"], parsed["args"]))
                 except json.JSONDecodeError:
                     pass
                 start_pos = -1
-    
+
     matches = potential_jsons
-    
+
     for tool_name, args in matches:
         try:
             # Create a mock tool call object
@@ -243,66 +260,73 @@ async def parse_json_tool_calls(text: str, tool_callback: Optional[ToolCallback]
                     self.tool_name = tool_name
                     self.args = args
                     self.tool_call_id = f"fallback_{datetime.now().timestamp()}"
-            
+
             class MockNode:
                 pass
-            
+
             # Execute the tool through the callback
             mock_call = MockToolCall(tool_name, args)
             mock_node = MockNode()
-            
+
             await tool_callback(mock_call, mock_node)
-            
+
             if state_manager.session.show_thoughts:
                 from tunacode.ui import console as ui
+
                 await ui.muted(f"🔧 FALLBACK: Executed {tool_name} via JSON parsing")
-                
+
         except Exception as e:
             if state_manager.session.show_thoughts:
                 from tunacode.ui import console as ui
+
                 await ui.error(f"❌ Error executing fallback tool {tool_name}: {str(e)}")
 
 
-async def extract_and_execute_tool_calls(text: str, tool_callback: Optional[ToolCallback], state_manager: StateManager):
+async def extract_and_execute_tool_calls(
+    text: str, tool_callback: Optional[ToolCallback], state_manager: StateManager
+):
     """
     Extract tool calls from text content and execute them.
     Supports multiple formats for maximum compatibility.
     """
     if not tool_callback:
         return
-    
+
     # Format 1: {"tool": "name", "args": {...}}
     await parse_json_tool_calls(text, tool_callback, state_manager)
-    
+
     # Format 2: Tool calls in code blocks
     code_block_pattern = r'```json\s*(\{(?:[^{}]|"[^"]*"|(?:\{[^}]*\}))*"tool"(?:[^{}]|"[^"]*"|(?:\{[^}]*\}))*\})\s*```'
     code_matches = re.findall(code_block_pattern, text, re.MULTILINE | re.DOTALL)
-    
+
     for match in code_matches:
         try:
             tool_data = json.loads(match)
-            if 'tool' in tool_data and 'args' in tool_data:
+            if "tool" in tool_data and "args" in tool_data:
+
                 class MockToolCall:
                     def __init__(self, tool_name: str, args: dict):
                         self.tool_name = tool_name
                         self.args = args
                         self.tool_call_id = f"codeblock_{datetime.now().timestamp()}"
-                
+
                 class MockNode:
                     pass
-                
-                mock_call = MockToolCall(tool_data['tool'], tool_data['args'])
+
+                mock_call = MockToolCall(tool_data["tool"], tool_data["args"])
                 mock_node = MockNode()
-                
+
                 await tool_callback(mock_call, mock_node)
-                
+
                 if state_manager.session.show_thoughts:
                     from tunacode.ui import console as ui
+
                     await ui.muted(f"🔧 FALLBACK: Executed {tool_data['tool']} from code block")
-                    
+
         except (json.JSONDecodeError, KeyError, Exception) as e:
             if state_manager.session.show_thoughts:
                 from tunacode.ui import console as ui
+
                 await ui.error(f"❌ Error parsing code block tool call: {str(e)}")
 
 
@@ -316,22 +340,24 @@ async def process_request(
     mh = state_manager.session.messages.copy()
     # Get max iterations from config (default: 20)
     max_iterations = state_manager.session.user_config.get("settings", {}).get("max_iterations", 20)
-    
+
     async with agent.iter(message, message_history=mh) as agent_run:
         i = 0
         async for node in agent_run:
             await _process_node(node, tool_callback, state_manager)
             i += 1
-            
+
             # Display iteration progress if thoughts are enabled
             if state_manager.session.show_thoughts and i > 1:
                 from tunacode.ui import console as ui
+
                 await ui.muted(f"🔄 Iteration {i}/{max_iterations}")
-            
+
             if i >= max_iterations:
                 if state_manager.session.show_thoughts:
                     from tunacode.ui import console as ui
+
                     await ui.warning(f"⚠️ Reached maximum iterations ({max_iterations})")
                 break
-                
+
         return agent_run

tunacode/core/agents/orchestrator.py

@@ -0,0 +1,99 @@
+"""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, ModelName
+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
+
+        # 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] = []
+        for mutate_flag, group in itertools.groupby(tasks, key=lambda t: t.mutate):
+            if mutate_flag:
+                for t in group:
+                    results.append(await self._run_sub_task(t, model))
+            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]
+                results.extend(await asyncio.gather(*coros))
+
+        console.print("\n[green]Orchestrator completed all tasks successfully![/green]")
+
+        return results

tunacode/core/agents/planner_schema.py

@@ -0,0 +1,9 @@
+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

@@ -0,0 +1,51 @@
+"""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
+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()
+
+        # Use iter() like main.py does to get the full run context
+        async with agent.iter(request) as agent_run:
+            async for _ in agent_run:
+                pass  # Let it complete
+
+        return agent_run

tunacode/core/background/manager.py

@@ -0,0 +1,36 @@
+"""Asynchronous background task management utilities."""
+
+from __future__ import annotations
+
+import asyncio
+import uuid
+from collections import defaultdict
+from typing import Awaitable, Callable, Dict, List
+
+
+class BackgroundTaskManager:
+    """Simple manager for background asyncio tasks."""
+
+    def __init__(self) -> None:
+        self.tasks: Dict[str, asyncio.Task] = {}
+        self.listeners: Dict[str, List[Callable[[asyncio.Task], None]]] = defaultdict(list)
+
+    def spawn(self, coro: Awaitable, *, name: str | None = None) -> str:
+        task_id = name or uuid.uuid4().hex[:8]
+        task = asyncio.create_task(coro, name=task_id)
+        self.tasks[task_id] = task
+        task.add_done_callback(self._notify)
+        return task_id
+
+    def _notify(self, task: asyncio.Task) -> None:
+        for cb in self.listeners.get(task.get_name(), []):
+            cb(task)
+
+    async def shutdown(self) -> None:
+        for task in self.tasks.values():
+            task.cancel()
+        if self.tasks:
+            await asyncio.gather(*self.tasks.values(), return_exceptions=True)
+
+
+BG_MANAGER = BackgroundTaskManager()

tunacode/core/llm/planner.py

@@ -0,0 +1,63 @@
+import json
+from typing import List
+
+from ...types import ModelName
+from ..agents.planner_schema import Task
+from ..state import StateManager
+
+_SYSTEM = """You are a senior software project planner.
+
+Your job is to break down a USER_REQUEST into a logical sequence of tasks.
+
+Guidelines:
+1. Use the FEWEST tasks possible - combine related operations
+2. Order tasks logically - reads before writes, understand before modify
+3. Mark read-only tasks (reading files, searching, analyzing) as mutate: false
+4. Mark modifying tasks (writing, updating, creating files) as mutate: true
+5. Write clear, actionable descriptions
+
+Each task MUST have:
+- id: Sequential number starting from 1
+- description: Clear description of what needs to be done
+- mutate: true if the task modifies files/code, false if it only reads/analyzes
+
+Return ONLY a valid JSON array of tasks, no other text.
+Example:
+[
+  {"id": 1, "description": "Read the main.py file to understand the structure", "mutate": false},
+  {"id": 2, "description": "Update the function to handle edge cases", "mutate": true}
+]"""
+
+
+async def make_plan(request: str, model: ModelName, state_manager: StateManager) -> List[Task]:
+    """Generate an execution plan from a user request using TunaCode's LLM infrastructure."""
+    # Lazy import to avoid circular dependencies
+    from rich.console import Console
+
+    from ..agents.main import get_agent_tool
+
+    console = Console()
+    Agent, _ = get_agent_tool()
+
+    # Show planning is starting
+    console.print("\n[dim][Planning] Breaking down request into tasks...[/dim]")
+
+    # Create a simple planning agent
+    planner = Agent(
+        model=model,
+        system_prompt=_SYSTEM,
+        result_type=List[Task],
+    )
+
+    # Get the plan from the agent
+    result = await planner.run(request)
+    tasks = result.data
+
+    # Display the plan
+    console.print(f"[dim][Planning] Generated {len(tasks)} tasks:[/dim]")
+    for task in tasks:
+        task_type = "WRITE" if task.mutate else "READ"
+        console.print(f"[dim]  Task {task.id}: {task_type} - {task.description}[/dim]")
+    console.print("")
+
+    return tasks