tunacode-cli 0.0.18__tar.gz → 0.0.21__tar.gz

{tunacode_cli-0.0.18 → tunacode_cli-0.0.21}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tunacode-cli
-Version: 0.0.18
+Version: 0.0.21
 Summary: Your agentic CLI developer.
 Author-email: larock22 <noreply@github.com>
 License-Expression: MIT
@@ -58,16 +58,20 @@ Dynamic: license-file
 
 ---
 
-### Recent Updates (v0.0.15)
-
-- **🐚 Shell Command Support**: Execute shell commands directly with `!command` or open interactive shell with `!`
-- **🔧 Enhanced Bash Tool**: Advanced bash execution with timeouts, working directory, and environment variables
-- **🔧 JSON Tool Parsing Fallback**: Automatic recovery when API providers fail with structured tool calling
-- **⚡ Enhanced Reliability**: Fixed parameter naming issues that caused tool schema errors
-- **🔄 Configuration Management**: New `/refresh` command to reload config without restart
-- **🧠 Improved ReAct Reasoning**: Enhanced iteration limits (now defaults to 20) and better thought processing
-- **🛠️ New Debug Commands**: `/parsetools` for manual JSON parsing, `/iterations` for controlling reasoning depth
-- **📊 Better Error Recovery**: Multiple fallback mechanisms for various failure scenarios
+### Recent Updates (v0.0.18)
+
+- **Advanced Agent Orchestration**: New orchestrator system for complex multi-step tasks with planning visibility
+- **Background Task Manager**: Asynchronous background processing for long-running operations
+- **Read-Only Agent**: Specialized agent for safe codebase exploration without modification risks
+- **Planning Transparency**: See the AI's planning process before execution with detailed task breakdowns
+- **Shell Command Support**: Execute shell commands directly with `!command` or open interactive shell with `!`
+- **Enhanced Bash Tool**: Advanced bash execution with timeouts, working directory, and environment variables
+- **JSON Tool Parsing Fallback**: Automatic recovery when API providers fail with structured tool calling
+- **Enhanced Reliability**: Fixed parameter naming issues that caused tool schema errors
+- **Configuration Management**: New `/refresh` command to reload config without restart
+- **Improved ReAct Reasoning**: Enhanced iteration limits (now defaults to 20) and better thought processing
+- **New Debug Commands**: `/parsetools` for manual JSON parsing, `/iterations` for controlling reasoning depth
+- **Better Error Recovery**: Multiple fallback mechanisms for various failure scenarios
 
 ### Core Features
 
@@ -401,7 +405,14 @@ src/tunacode/
 │
 ├── core/                 # Core Application Logic
 │   ├── agents/           # AI Agent System
-│   │   └── main.py       # Primary agent implementation (pydantic-ai)
+│   │   ├── main.py       # Primary agent implementation (pydantic-ai)
+│   │   ├── orchestrator.py # Complex task orchestration and planning
+│   │   ├── planner_schema.py # Planning data models
+│   │   └── readonly.py   # Read-only agent for safe exploration
+│   ├── background/       # Background Task Management
+│   │   └── manager.py    # Async background task execution
+│   ├── llm/              # LLM Integration
+│   │   └── planner.py    # LLM-based task planning
 │   ├── setup/            # Application Setup & Initialization
 │   │   ├── agent_setup.py     # Agent configuration
 │   │   ├── base.py           # Setup step base class
@@ -450,7 +461,7 @@ src/tunacode/
 ├── exceptions.py      # Custom exceptions
 ├── types.py           # Type definitions
 └── prompts/
-    └── system.txt     # System prompts for AI agent
+    └── system.md      # System prompts for AI agent
 ```
 
 ### Key Components
@@ -459,6 +470,8 @@ src/tunacode/
 | -------------------- | ------------------------ | ------------------------------- |
 | **CLI Layer**        | Command parsing and REPL | `cli/main.py`, `cli/repl.py`    |
 | **Agent System**     | AI-powered assistance    | `core/agents/main.py`           |
+| **Orchestrator**     | Complex task planning    | `core/agents/orchestrator.py`   |
+| **Background Tasks** | Async task execution     | `core/background/manager.py`    |
 | **Tool System**      | File/command operations  | `tools/*.py`                    |
 | **State Management** | Session state tracking   | `core/state.py`                 |
 | **UI Framework**     | Rich terminal interface  | `ui/output.py`, `ui/console.py` |
@@ -523,6 +536,9 @@ While TunaCode builds on the foundation of sidekick-cli, we've made several arch
 
 - **JSON Tool Parsing Fallback**: Added fallback parsing for when API providers fail with structured tool calling
 - **Parallel Search Tools**: New `bash` and `grep` tools with parallel execution for codebase navigation
+- **Agent Orchestration**: Advanced orchestrator for complex multi-step tasks with planning transparency
+- **Background Processing**: Asynchronous task manager for long-running operations
+- **Read-Only Agent**: Safe exploration mode that prevents accidental modifications
 - **ReAct Reasoning**: Implemented ReAct (Reasoning + Acting) patterns with configurable iteration limits
 - **Dynamic Configuration**: Added `/refresh` command and modified configuration management
 - **Safety Changes**: Removed automatic git commits and `/undo` command - requires explicit git usage

{tunacode_cli-0.0.18 → tunacode_cli-0.0.21}/README.md

@@ -22,16 +22,20 @@
 
 ---
 
-### Recent Updates (v0.0.15)
-
-- **🐚 Shell Command Support**: Execute shell commands directly with `!command` or open interactive shell with `!`
-- **🔧 Enhanced Bash Tool**: Advanced bash execution with timeouts, working directory, and environment variables
-- **🔧 JSON Tool Parsing Fallback**: Automatic recovery when API providers fail with structured tool calling
-- **⚡ Enhanced Reliability**: Fixed parameter naming issues that caused tool schema errors
-- **🔄 Configuration Management**: New `/refresh` command to reload config without restart
-- **🧠 Improved ReAct Reasoning**: Enhanced iteration limits (now defaults to 20) and better thought processing
-- **🛠️ New Debug Commands**: `/parsetools` for manual JSON parsing, `/iterations` for controlling reasoning depth
-- **📊 Better Error Recovery**: Multiple fallback mechanisms for various failure scenarios
+### Recent Updates (v0.0.18)
+
+- **Advanced Agent Orchestration**: New orchestrator system for complex multi-step tasks with planning visibility
+- **Background Task Manager**: Asynchronous background processing for long-running operations
+- **Read-Only Agent**: Specialized agent for safe codebase exploration without modification risks
+- **Planning Transparency**: See the AI's planning process before execution with detailed task breakdowns
+- **Shell Command Support**: Execute shell commands directly with `!command` or open interactive shell with `!`
+- **Enhanced Bash Tool**: Advanced bash execution with timeouts, working directory, and environment variables
+- **JSON Tool Parsing Fallback**: Automatic recovery when API providers fail with structured tool calling
+- **Enhanced Reliability**: Fixed parameter naming issues that caused tool schema errors
+- **Configuration Management**: New `/refresh` command to reload config without restart
+- **Improved ReAct Reasoning**: Enhanced iteration limits (now defaults to 20) and better thought processing
+- **New Debug Commands**: `/parsetools` for manual JSON parsing, `/iterations` for controlling reasoning depth
+- **Better Error Recovery**: Multiple fallback mechanisms for various failure scenarios
 
 ### Core Features
 
@@ -365,7 +369,14 @@ src/tunacode/
 │
 ├── core/                 # Core Application Logic
 │   ├── agents/           # AI Agent System
-│   │   └── main.py       # Primary agent implementation (pydantic-ai)
+│   │   ├── main.py       # Primary agent implementation (pydantic-ai)
+│   │   ├── orchestrator.py # Complex task orchestration and planning
+│   │   ├── planner_schema.py # Planning data models
+│   │   └── readonly.py   # Read-only agent for safe exploration
+│   ├── background/       # Background Task Management
+│   │   └── manager.py    # Async background task execution
+│   ├── llm/              # LLM Integration
+│   │   └── planner.py    # LLM-based task planning
 │   ├── setup/            # Application Setup & Initialization
 │   │   ├── agent_setup.py     # Agent configuration
 │   │   ├── base.py           # Setup step base class
@@ -414,7 +425,7 @@ src/tunacode/
 ├── exceptions.py      # Custom exceptions
 ├── types.py           # Type definitions
 └── prompts/
-    └── system.txt     # System prompts for AI agent
+    └── system.md      # System prompts for AI agent
 ```
 
 ### Key Components
@@ -423,6 +434,8 @@ src/tunacode/
 | -------------------- | ------------------------ | ------------------------------- |
 | **CLI Layer**        | Command parsing and REPL | `cli/main.py`, `cli/repl.py`    |
 | **Agent System**     | AI-powered assistance    | `core/agents/main.py`           |
+| **Orchestrator**     | Complex task planning    | `core/agents/orchestrator.py`   |
+| **Background Tasks** | Async task execution     | `core/background/manager.py`    |
 | **Tool System**      | File/command operations  | `tools/*.py`                    |
 | **State Management** | Session state tracking   | `core/state.py`                 |
 | **UI Framework**     | Rich terminal interface  | `ui/output.py`, `ui/console.py` |
@@ -487,6 +500,9 @@ While TunaCode builds on the foundation of sidekick-cli, we've made several arch
 
 - **JSON Tool Parsing Fallback**: Added fallback parsing for when API providers fail with structured tool calling
 - **Parallel Search Tools**: New `bash` and `grep` tools with parallel execution for codebase navigation
+- **Agent Orchestration**: Advanced orchestrator for complex multi-step tasks with planning transparency
+- **Background Processing**: Asynchronous task manager for long-running operations
+- **Read-Only Agent**: Safe exploration mode that prevents accidental modifications
 - **ReAct Reasoning**: Implemented ReAct (Reasoning + Acting) patterns with configurable iteration limits
 - **Dynamic Configuration**: Added `/refresh` command and modified configuration management
 - **Safety Changes**: Removed automatic git commits and `/undo` command - requires explicit git usage

{tunacode_cli-0.0.18 → tunacode_cli-0.0.21}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "tunacode-cli"
-version = "0.0.18"
+version = "0.0.21"
 description = "Your agentic CLI developer."
 keywords = ["cli", "agent", "development", "automation"]
 readme = "README.md"

{tunacode_cli-0.0.18 → tunacode_cli-0.0.21}/src/tunacode/cli/commands.py

@@ -167,6 +167,39 @@ class ThoughtsCommand(SimpleCommand):
         await ui.success(f"Thought display {status}")
 
 
+class ArchitectCommand(SimpleCommand):
+    """Toggle architect mode for task planning and orchestration."""
+
+    def __init__(self):
+        super().__init__(
+            CommandSpec(
+                name="architect",
+                aliases=["/architect"],
+                description="Toggle architect mode (task planning & orchestration)",
+                category=CommandCategory.DEBUG,
+            )
+        )
+
+    async def execute(self, args: List[str], context: CommandContext) -> None:
+        state = context.state_manager.session
+        if args:
+            arg = args[0].lower()
+            if arg in {"on", "1", "true"}:
+                state.architect_mode = True
+            elif arg in {"off", "0", "false"}:
+                state.architect_mode = False
+            else:
+                await ui.error("Usage: /architect [on|off]")
+                return
+        else:
+            state.architect_mode = not getattr(state, 'architect_mode', False)
+        status = "ON" if state.architect_mode else "OFF"
+        if state.architect_mode:
+            await ui.success(f"Architect mode {status} - Requests will be planned before execution")
+        else:
+            await ui.success(f"Architect mode {status} - Using direct execution")
+
+
 class IterationsCommand(SimpleCommand):
     """Configure maximum agent iterations for ReAct reasoning."""
 
@@ -720,6 +753,7 @@ class CommandRegistry:
             YoloCommand,
             DumpCommand,
             ThoughtsCommand,
+            ArchitectCommand,
             IterationsCommand,
             ClearCommand,
             FixCommand,

{tunacode_cli-0.0.18 → tunacode_cli-0.0.21}/src/tunacode/cli/main.py

@@ -50,7 +50,9 @@ def main(
             await setup(run_setup, state_manager, cli_config)
             await repl(state_manager)
         except Exception as e:
-            await ui.error(str(e))
+            import traceback
+
+            await ui.error(f"{str(e)}\n\nTraceback:\n{traceback.format_exc()}")
 
         has_update, latest_version = await update_task
         if has_update:

{tunacode_cli-0.0.18 → tunacode_cli-0.0.21}/src/tunacode/cli/repl.py

@@ -17,6 +17,7 @@ from pydantic_ai.exceptions import UnexpectedModelBehavior
 from tunacode.configuration.settings import ApplicationSettings
 from tunacode.core.agents import main as agent
 from tunacode.core.agents.main import patch_tool_messages
+from tunacode.core.agents.orchestrator import OrchestratorAgent
 from tunacode.core.tool_handler import ToolHandler
 from tunacode.exceptions import AgentError, UserAbortError, ValidationError
 from tunacode.ui import console as ui
@@ -160,41 +161,69 @@ async def process_request(text: str, state_manager: StateManager, output: bool =
         True, state_manager.session.spinner, state_manager
     )
     try:
-        # Expand @file references before sending to the agent
-        try:
-            from tunacode.utils.text_utils import expand_file_refs
-
-            text = expand_file_refs(text)
-        except ValueError as e:
-            await ui.error(str(e))
-            return
-
         # Patch any orphaned tool calls from previous requests before proceeding
         patch_tool_messages("Tool execution was interrupted", state_manager)
 
+        # Track message start for thoughts display
+        start_idx = len(state_manager.session.messages)
+
         # Create a partial function that includes state_manager
         def tool_callback_with_state(part, node):
             return _tool_handler(part, node, state_manager)
 
-        start_idx = len(state_manager.session.messages)
-        res = await agent.process_request(
-            state_manager.session.current_model,
-            text,
-            state_manager,
-            tool_callback=tool_callback_with_state,
-        )
-        if output:
-            if state_manager.session.show_thoughts:
-                new_msgs = state_manager.session.messages[start_idx:]
-                for msg in new_msgs:
-                    if isinstance(msg, dict) and "thought" in msg:
-                        await ui.muted(f"THOUGHT: {msg['thought']}")
-            # Check if result exists and has output
-            if hasattr(res, "result") and res.result is not None and hasattr(res.result, "output"):
-                await ui.agent(res.result.output)
-            else:
-                # Fallback: show that the request was processed
-                await ui.muted("Request completed")
+        # Check if architect mode is enabled
+        if getattr(state_manager.session, 'architect_mode', False):
+            # Expand @file references before sending to the orchestrator
+            try:
+                from tunacode.utils.text_utils import expand_file_refs
+
+                text = expand_file_refs(text)
+            except ValueError as e:
+                await ui.error(str(e))
+                return
+            # Use orchestrator for planning and execution
+            orchestrator = OrchestratorAgent(state_manager)
+            results = await orchestrator.run(text, state_manager.session.current_model)
+            
+            if output:
+                # Process results from all sub-agents
+                for res in results:
+                    # Check if result exists and has output
+                    if hasattr(res, "result") and res.result is not None and hasattr(res.result, "output"):
+                        await ui.agent(res.result.output)
+                
+                if not results:
+                    # Fallback: show that the request was processed
+                    await ui.muted("Request completed")
+        else:
+            # Expand @file references before sending to the agent
+            try:
+                from tunacode.utils.text_utils import expand_file_refs
+
+                text = expand_file_refs(text)
+            except ValueError as e:
+                await ui.error(str(e))
+                return
+            
+            # Use normal agent processing
+            res = await agent.process_request(
+                state_manager.session.current_model,
+                text,
+                state_manager,
+                tool_callback=tool_callback_with_state,
+            )
+            if output:
+                if state_manager.session.show_thoughts:
+                    new_msgs = state_manager.session.messages[start_idx:]
+                    for msg in new_msgs:
+                        if isinstance(msg, dict) and "thought" in msg:
+                            await ui.muted(f"THOUGHT: {msg['thought']}")
+                # Check if result exists and has output
+                if hasattr(res, "result") and res.result is not None and hasattr(res.result, "output"):
+                    await ui.agent(res.result.output)
+                else:
+                    # Fallback: show that the request was processed
+                    await ui.muted("Request completed")
     except CancelledError:
         await ui.muted("Request cancelled")
     except UserAbortError:

{tunacode_cli-0.0.18 → tunacode_cli-0.0.21}/src/tunacode/constants.py

@@ -7,7 +7,7 @@ Centralizes all magic strings, UI text, error messages, and application constant
 
 # Application info
 APP_NAME = "TunaCode"
-APP_VERSION = "0.0.18"
+APP_VERSION = "0.0.21"
 
 # File patterns
 GUIDE_FILE_PATTERN = "{name}.md"

tunacode_cli-0.0.21/src/tunacode/core/agents/__init__.py

@@ -0,0 +1,12 @@
+"""Agent helper modules."""
+
+from .main import get_or_create_agent, process_request
+from .orchestrator import OrchestratorAgent
+from .readonly import ReadOnlyAgent
+
+__all__ = [
+    "process_request",
+    "get_or_create_agent",
+    "OrchestratorAgent",
+    "ReadOnlyAgent",
+]

{tunacode_cli-0.0.18 → tunacode_cli-0.0.21}/src/tunacode/core/agents/main.py

@@ -134,7 +134,7 @@ def get_or_create_agent(model: ModelName, state_manager: StateManager) -> Pydant
         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()

tunacode_cli-0.0.21/src/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_cli-0.0.21/src/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_cli-0.0.21/src/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_cli-0.0.21/src/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_cli-0.0.21/src/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