tunacode-cli 0.0.29__py3-none-any.whl → 0.0.31__py3-none-any.whl

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)

tunacode/core/llm/planner.py

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