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

tunacode/core/agents/agent_components/agent_config.py

@@ -8,6 +8,7 @@ from tunacode.core.logging.logger import get_logger
 from tunacode.core.state import StateManager
 from tunacode.services.mcp import get_mcp_servers
 from tunacode.tools.bash import bash
+from tunacode.tools.present_plan import create_present_plan_tool
 from tunacode.tools.glob import glob
 from tunacode.tools.grep import grep
 from tunacode.tools.list_dir import list_dir
@@ -65,7 +66,11 @@ def load_tunacode_context() -> str:
 
 def get_or_create_agent(model: ModelName, state_manager: StateManager) -> PydanticAgent:
     """Get existing agent or create new one for the specified model."""
+    import logging
+    logger = logging.getLogger(__name__)
+    
     if model not in state_manager.session.agents:
+        logger.debug(f"Creating new agent for model {model}, plan_mode={state_manager.is_plan_mode()}")
         max_retries = state_manager.session.user_config.get("settings", {}).get("max_retries", 3)
 
         # Lazy import Agent and Tool
@@ -78,8 +83,105 @@ def get_or_create_agent(model: ModelName, state_manager: StateManager) -> Pydant
         # Load TUNACODE.md context
         system_prompt += load_tunacode_context()
 
-        # Initialize todo tool
+        # Add plan mode context if in plan mode
+        if state_manager.is_plan_mode():
+            # REMOVE all TUNACODE_TASK_COMPLETE instructions from the system prompt
+            system_prompt = system_prompt.replace("TUNACODE_TASK_COMPLETE", "PLAN_MODE_TASK_PLACEHOLDER")
+            # Remove the completion guidance that conflicts with plan mode
+            lines_to_remove = [
+                "When a task is COMPLETE, start your response with: TUNACODE_TASK_COMPLETE",
+                "4. When a task is COMPLETE, start your response with: TUNACODE_TASK_COMPLETE", 
+                "**How to signal completion:**",
+                "TUNACODE_TASK_COMPLETE",
+                "[Your summary of what was accomplished]",
+                "**IMPORTANT**: Always evaluate if you've completed the task. If yes, use TUNACODE_TASK_COMPLETE.",
+                "This prevents wasting iterations and API calls."
+            ]
+            for line in lines_to_remove:
+                system_prompt = system_prompt.replace(line, "")
+            plan_mode_override = """
+🔍 PLAN MODE - YOU MUST USE THE present_plan TOOL 🔍
+
+CRITICAL: You are in Plan Mode. You MUST execute the present_plan TOOL, not show it as text.
+
+❌ WRONG - DO NOT SHOW THE FUNCTION AS TEXT:
+```
+present_plan(title="...", ...)  # THIS IS WRONG - DON'T SHOW AS CODE
+```
+
+✅ CORRECT - ACTUALLY EXECUTE THE TOOL:
+You must EXECUTE present_plan as a tool call, just like you execute read_file or grep.
+
+CRITICAL RULES:
+1. DO NOT show present_plan() as code or text
+2. DO NOT write "Here's the plan" or any text description
+3. DO NOT use TUNACODE_TASK_COMPLETE
+4. DO NOT use markdown code blocks for present_plan
+
+YOU MUST EXECUTE THE TOOL:
+When the user asks you to "plan" something, you must:
+1. Research using read_only tools (optional)
+2. EXECUTE present_plan tool with the plan data
+3. The tool will handle displaying the plan
+
+Example of CORRECT behavior:
+User: "plan a markdown file"
+You: [Execute read_file/grep if needed for research]
+     [Then EXECUTE present_plan tool - not as text but as an actual tool call]
+
+Remember: present_plan is a TOOL like read_file or grep. You must EXECUTE it, not SHOW it.
+
+Available tools:
+- read_file, grep, list_dir, glob: For research
+- present_plan: EXECUTE this tool to present the plan (DO NOT show as text)
+
+"""
+            # COMPLETELY REPLACE system prompt in plan mode - nuclear option
+            system_prompt = """
+🔧 PLAN MODE - TOOL EXECUTION ONLY 🔧
+
+You are a planning assistant that ONLY communicates through tool execution.
+
+CRITICAL: You cannot respond with text. You MUST use tools for everything.
+
+AVAILABLE TOOLS:
+- read_file(filepath): Read file contents
+- grep(pattern): Search for text patterns  
+- list_dir(directory): List directory contents
+- glob(pattern): Find files matching patterns
+- present_plan(title, overview, steps, files_to_create, success_criteria): Present structured plan
+
+MANDATORY WORKFLOW:
+1. User asks you to plan something
+2. You research using read-only tools (if needed)
+3. You EXECUTE present_plan tool with structured data
+4. DONE
+
+FORBIDDEN:
+- Text responses
+- Showing function calls as code
+- Saying "here is the plan"
+- Any text completion
+
+EXAMPLE:
+User: "plan a markdown file"
+You: [Call read_file or grep for research if needed]
+     [Call present_plan tool with actual parameters - NOT as text]
+
+The present_plan tool takes these parameters:
+- title: Brief title string
+- overview: What the plan accomplishes  
+- steps: List of implementation steps
+- files_to_create: List of files to create
+- success_criteria: List of success criteria
+
+YOU MUST EXECUTE present_plan TOOL TO COMPLETE ANY PLANNING TASK.
+"""
+
+        # Initialize tools that need state manager
         todo_tool = TodoTool(state_manager=state_manager)
+        present_plan = create_present_plan_tool(state_manager)
+        logger.debug(f"Tools initialized, present_plan available: {present_plan is not None}")
 
         # Add todo context if available
         try:
@@ -89,12 +191,21 @@ def get_or_create_agent(model: ModelName, state_manager: StateManager) -> Pydant
         except Exception as e:
             logger.warning(f"Warning: Failed to load todos: {e}")
 
-        # Create agent with all tools
-        state_manager.session.agents[model] = Agent(
-            model=model,
-            system_prompt=system_prompt,
-            tools=[
+        # Create tool list based on mode
+        if state_manager.is_plan_mode():
+            # Plan mode: Only read-only tools + present_plan
+            tools_list = [
+                Tool(present_plan, max_retries=max_retries),
+                Tool(glob, max_retries=max_retries),
+                Tool(grep, max_retries=max_retries),
+                Tool(list_dir, max_retries=max_retries),
+                Tool(read_file, max_retries=max_retries),
+            ]
+        else:
+            # Normal mode: All tools
+            tools_list = [
                 Tool(bash, max_retries=max_retries),
+                Tool(present_plan, max_retries=max_retries),
                 Tool(glob, max_retries=max_retries),
                 Tool(grep, max_retries=max_retries),
                 Tool(list_dir, max_retries=max_retries),
@@ -103,7 +214,23 @@ def get_or_create_agent(model: ModelName, state_manager: StateManager) -> Pydant
                 Tool(todo_tool._execute, max_retries=max_retries),
                 Tool(update_file, max_retries=max_retries),
                 Tool(write_file, max_retries=max_retries),
-            ],
+            ]
+        
+        # Log which tools are being registered
+        logger.debug(f"Creating agent: plan_mode={state_manager.is_plan_mode()}, tools={len(tools_list)}")
+        if state_manager.is_plan_mode():
+            logger.debug(f"PLAN MODE TOOLS: {[str(tool) for tool in tools_list]}")
+            logger.debug(f"present_plan tool type: {type(present_plan)}")
+        
+        if "PLAN MODE - YOU MUST USE THE present_plan TOOL" in system_prompt:
+            logger.debug("✅ Plan mode instructions ARE in system prompt")
+        else:
+            logger.debug("❌ Plan mode instructions NOT in system prompt")
+        
+        state_manager.session.agents[model] = Agent(
+            model=model,
+            system_prompt=system_prompt,
+            tools=tools_list,
             mcp_servers=get_mcp_servers(state_manager),
         )
     return state_manager.session.agents[model]

tunacode/core/agents/agent_components/node_processor.py

@@ -343,45 +343,46 @@ async def _process_tool_calls(
                             f"[bold #00d7ff]{batch_msg}...[/bold #00d7ff]", state_manager
                         )
 
-                        # Enhanced visual feedback for parallel execution
-                        await ui.muted("\n" + "=" * 60)
-                        await ui.muted(
-                            f"🚀 PARALLEL BATCH #{batch_id}: Executing {len(buffered_tasks)} read-only tools concurrently"
-                        )
-                        await ui.muted("=" * 60)
-
-                        # Display details of what's being executed
-                        for idx, (buffered_part, _) in enumerate(buffered_tasks, 1):
-                            tool_desc = f"  [{idx}] {buffered_part.tool_name}"
-                            if hasattr(buffered_part, "args") and isinstance(
-                                buffered_part.args, dict
-                            ):
-                                if (
-                                    buffered_part.tool_name == "read_file"
-                                    and "file_path" in buffered_part.args
-                                ):
-                                    tool_desc += f" → {buffered_part.args['file_path']}"
-                                elif (
-                                    buffered_part.tool_name == "grep"
-                                    and "pattern" in buffered_part.args
-                                ):
-                                    tool_desc += f" → pattern: '{buffered_part.args['pattern']}'"
-                                    if "include_files" in buffered_part.args:
-                                        tool_desc += (
-                                            f", files: '{buffered_part.args['include_files']}'"
-                                        )
-                                elif (
-                                    buffered_part.tool_name == "list_dir"
-                                    and "directory" in buffered_part.args
-                                ):
-                                    tool_desc += f" → {buffered_part.args['directory']}"
-                                elif (
-                                    buffered_part.tool_name == "glob"
-                                    and "pattern" in buffered_part.args
+                        # Enhanced visual feedback for parallel execution (suppress in plan mode)
+                        if not state_manager.is_plan_mode():
+                            await ui.muted("\n" + "=" * 60)
+                            await ui.muted(
+                                f"🚀 PARALLEL BATCH #{batch_id}: Executing {len(buffered_tasks)} read-only tools concurrently"
+                            )
+                            await ui.muted("=" * 60)
+
+                            # Display details of what's being executed
+                            for idx, (buffered_part, _) in enumerate(buffered_tasks, 1):
+                                tool_desc = f"  [{idx}] {buffered_part.tool_name}"
+                                if hasattr(buffered_part, "args") and isinstance(
+                                    buffered_part.args, dict
                                 ):
-                                    tool_desc += f" → pattern: '{buffered_part.args['pattern']}'"
-                            await ui.muted(tool_desc)
-                        await ui.muted("=" * 60)
+                                    if (
+                                        buffered_part.tool_name == "read_file"
+                                        and "file_path" in buffered_part.args
+                                    ):
+                                        tool_desc += f" → {buffered_part.args['file_path']}"
+                                    elif (
+                                        buffered_part.tool_name == "grep"
+                                        and "pattern" in buffered_part.args
+                                    ):
+                                        tool_desc += f" → pattern: '{buffered_part.args['pattern']}'"
+                                        if "include_files" in buffered_part.args:
+                                            tool_desc += (
+                                                f", files: '{buffered_part.args['include_files']}'"
+                                            )
+                                    elif (
+                                        buffered_part.tool_name == "list_dir"
+                                        and "directory" in buffered_part.args
+                                    ):
+                                        tool_desc += f" → {buffered_part.args['directory']}"
+                                    elif (
+                                        buffered_part.tool_name == "glob"
+                                        and "pattern" in buffered_part.args
+                                    ):
+                                        tool_desc += f" → pattern: '{buffered_part.args['pattern']}'"
+                                await ui.muted(tool_desc)
+                            await ui.muted("=" * 60)
 
                         await execute_tools_parallel(buffered_tasks, tool_callback)
 
@@ -391,10 +392,11 @@ async def _process_tool_calls(
                         )  # Assume 100ms per tool average
                         speedup = sequential_estimate / elapsed_time if elapsed_time > 0 else 1.0
 
-                        await ui.muted(
-                            f"✅ Parallel batch completed in {elapsed_time:.0f}ms "
-                            f"(~{speedup:.1f}x faster than sequential)\n"
-                        )
+                        if not state_manager.is_plan_mode():
+                            await ui.muted(
+                                f"✅ Parallel batch completed in {elapsed_time:.0f}ms "
+                                f"(~{speedup:.1f}x faster than sequential)\n"
+                            )
 
                         # Reset spinner message back to thinking
                         from tunacode.constants import UI_THINKING_MESSAGE

tunacode/core/state.py

@@ -15,6 +15,8 @@ from tunacode.types import (
     InputSessions,
     MessageHistory,
     ModelName,
+    PlanDoc,
+    PlanPhase,
     SessionId,
     TodoItem,
     ToolName,
@@ -84,6 +86,12 @@ class SessionState:
     task_hierarchy: dict[str, Any] = field(default_factory=dict)
     iteration_budgets: dict[str, int] = field(default_factory=dict)
     recursive_context_stack: list[dict[str, Any]] = field(default_factory=list)
+    
+    # Plan Mode state tracking
+    plan_mode: bool = False
+    plan_phase: Optional[PlanPhase] = None
+    current_plan: Optional[PlanDoc] = None
+    plan_approved: bool = False
 
     def update_token_count(self):
         """Calculates the total token count from messages and files in context."""
@@ -167,3 +175,39 @@ class StateManager:
     def reset_session(self) -> None:
         """Reset the session to a fresh state."""
         self._session = SessionState()
+
+    # Plan Mode methods
+    def enter_plan_mode(self) -> None:
+        """Enter plan mode - restricts to read-only operations."""
+        self._session.plan_mode = True
+        self._session.plan_phase = PlanPhase.PLANNING_RESEARCH
+        self._session.current_plan = None
+        self._session.plan_approved = False
+        # Clear agent cache to force recreation with plan mode tools
+        self._session.agents.clear()
+
+    def exit_plan_mode(self, plan: Optional[PlanDoc] = None) -> None:
+        """Exit plan mode with optional plan data."""
+        self._session.plan_mode = False
+        self._session.plan_phase = None
+        self._session.current_plan = plan
+        self._session.plan_approved = False
+        # Clear agent cache to force recreation without plan mode tools
+        self._session.agents.clear()
+
+    def approve_plan(self) -> None:
+        """Mark current plan as approved for execution."""
+        self._session.plan_approved = True
+        self._session.plan_mode = False
+
+    def is_plan_mode(self) -> bool:
+        """Check if currently in plan mode."""
+        return self._session.plan_mode
+
+    def set_current_plan(self, plan: PlanDoc) -> None:
+        """Set the current plan data."""
+        self._session.current_plan = plan
+
+    def get_current_plan(self) -> Optional[PlanDoc]:
+        """Get the current plan data."""
+        return self._session.current_plan

tunacode/core/tool_handler.py

@@ -41,6 +41,14 @@ class ToolHandler:
         Returns:
             bool: True if confirmation is required, False otherwise.
         """
+        # Never confirm present_plan - it has its own approval flow
+        if tool_name == "present_plan":
+            return False
+            
+        # Block write tools in plan mode
+        if self.is_tool_blocked_in_plan_mode(tool_name):
+            return True  # Force confirmation for blocked tools
+
         # Skip confirmation for read-only tools
         if is_read_only_tool(tool_name):
             return False
@@ -52,6 +60,18 @@ class ToolHandler:
 
         return not (self.state.session.yolo or tool_name in self.state.session.tool_ignore)
 
+    def is_tool_blocked_in_plan_mode(self, tool_name: ToolName) -> bool:
+        """Check if tool is blocked in plan mode."""
+        if not self.state.is_plan_mode():
+            return False
+        
+        # Allow present_plan tool to end planning phase
+        if tool_name == "present_plan":
+            return False
+            
+        # Allow read-only tools
+        return not is_read_only_tool(tool_name)
+
     def process_confirmation(self, response: ToolConfirmationResponse, tool_name: ToolName) -> bool:
         """
         Process the confirmation response.

tunacode/tools/exit_plan_mode.py

@@ -0,0 +1,191 @@
+"""Tool for exiting plan mode and presenting implementation plan."""
+
+from typing import Any, Dict, List
+
+from tunacode.tools.base import BaseTool
+from tunacode.ui import console as ui
+from tunacode.types import ToolResult
+
+
+class ExitPlanModeTool(BaseTool):
+    """Present implementation plan and exit plan mode."""
+    
+    def __init__(self, state_manager, ui_logger=None):
+        """Initialize the exit plan mode tool.
+        
+        Args:
+            state_manager: StateManager instance for controlling plan mode state
+            ui_logger: UI logger instance for displaying messages
+        """
+        super().__init__(ui_logger)
+        self.state_manager = state_manager
+    
+    @property
+    def tool_name(self) -> str:
+        return "exit_plan_mode"
+    
+    async def _execute(
+        self,
+        plan_title: str,
+        overview: str,
+        implementation_steps: List[str],
+        files_to_modify: List[str] = None,
+        files_to_create: List[str] = None,
+        risks_and_considerations: List[str] = None,
+        testing_approach: str = None,
+        success_criteria: List[str] = None,
+    ) -> ToolResult:
+        """Present the implementation plan and get user approval."""
+        
+        plan = {
+            "title": plan_title,
+            "overview": overview,
+            "files_to_modify": files_to_modify or [],
+            "files_to_create": files_to_create or [],
+            "implementation_steps": implementation_steps,
+            "risks_and_considerations": risks_and_considerations or [],
+            "testing_approach": testing_approach or "Manual testing of functionality",
+            "success_criteria": success_criteria or []
+        }
+        
+        # Present plan to user
+        await self._present_plan(plan)
+        
+        # Get user approval
+        approved = await self._get_user_approval()
+        
+        # Update state based on user approval
+        if approved:
+            # Store the plan and exit plan mode
+            self.state_manager.set_current_plan(plan)
+            self.state_manager.exit_plan_mode(plan)
+            await ui.success("✅ Plan approved! Exiting Plan Mode.")
+            return "Plan approved and Plan Mode exited. You can now execute the implementation using write tools (write_file, update_file, bash, run_command)."
+        else:
+            # Keep the plan but stay in plan mode
+            self.state_manager.set_current_plan(plan)
+            await ui.warning("❌ Plan rejected. Staying in Plan Mode for further research.")
+            return "Plan rejected. Continue researching and refine your approach. You remain in Plan Mode - only read-only tools are available."
+    
+    async def _present_plan(self, plan: Dict[str, Any]) -> None:
+        """Present the plan in a formatted way."""
+        # Build the entire plan output as a single string to avoid UI flooding
+        output = []
+        output.append("")
+        output.append("╭─────────────────────────────────────────────────────────╮")
+        output.append("│                  📋 IMPLEMENTATION PLAN                │")
+        output.append("╰─────────────────────────────────────────────────────────╯")
+        output.append("")
+        output.append(f"🎯 {plan['title']}")
+        output.append("")
+        
+        if plan["overview"]:
+            output.append(f"📝 Overview: {plan['overview']}")
+            output.append("")
+        
+        # Files section
+        if plan["files_to_modify"]:
+            output.append("📝 Files to Modify:")
+            for f in plan["files_to_modify"]:
+                output.append(f"  • {f}")
+            output.append("")
+            
+        if plan["files_to_create"]:
+            output.append("📄 Files to Create:")
+            for f in plan["files_to_create"]:
+                output.append(f"  • {f}")
+            output.append("")
+        
+        # Implementation steps
+        output.append("🔧 Implementation Steps:")
+        for i, step in enumerate(plan["implementation_steps"], 1):
+            output.append(f"  {i}. {step}")
+        output.append("")
+        
+        # Testing approach
+        if plan["testing_approach"]:
+            output.append(f"🧪 Testing Approach: {plan['testing_approach']}")
+            output.append("")
+        
+        # Success criteria
+        if plan["success_criteria"]:
+            output.append("✅ Success Criteria:")
+            for criteria in plan["success_criteria"]:
+                output.append(f"  • {criteria}")
+            output.append("")
+        
+        # Risks and considerations
+        if plan["risks_and_considerations"]:
+            output.append("⚠️ Risks & Considerations:")
+            for risk in plan["risks_and_considerations"]:
+                output.append(f"  • {risk}")
+            output.append("")
+        
+        # Print everything at once
+        await ui.info("\n".join(output))
+    
+    async def _get_user_approval(self) -> bool:
+        """Get user approval for the plan."""
+        try:
+            from prompt_toolkit import PromptSession
+            from prompt_toolkit.patch_stdout import patch_stdout
+            
+            session = PromptSession()
+            
+            with patch_stdout():
+                response = await session.prompt_async("\n🤔 Approve this implementation plan? (y/n): ")
+            
+            return response.strip().lower() in ['y', 'yes', 'approve']
+        except (KeyboardInterrupt, EOFError):
+            return False
+
+
+def create_exit_plan_mode_tool(state_manager):
+    """
+    Factory function to create exit_plan_mode tool with the correct state manager.
+    
+    Args:
+        state_manager: The StateManager instance to use
+        
+    Returns:
+        Callable: The exit_plan_mode function bound to the provided state manager
+    """
+    async def exit_plan_mode(
+        plan_title: str,
+        overview: str,
+        implementation_steps: List[str],
+        files_to_modify: List[str] = None,
+        files_to_create: List[str] = None,
+        risks_and_considerations: List[str] = None,
+        testing_approach: str = None,
+        success_criteria: List[str] = None,
+    ) -> str:
+        """
+        Present implementation plan and exit plan mode.
+        
+        Args:
+            plan_title: Brief title for the implementation plan
+            overview: High-level overview of the changes needed
+            implementation_steps: Ordered list of implementation steps  
+            files_to_modify: List of files that need to be modified
+            files_to_create: List of new files to be created
+            risks_and_considerations: Potential risks or important considerations
+            testing_approach: Approach for testing the implementation
+            success_criteria: Criteria for considering the implementation successful
+            
+        Returns:
+            str: Result message indicating plan approval status
+        """
+        tool = ExitPlanModeTool(state_manager=state_manager)
+        return await tool._execute(
+            plan_title=plan_title,
+            overview=overview,
+            implementation_steps=implementation_steps,
+            files_to_modify=files_to_modify,
+            files_to_create=files_to_create,
+            risks_and_considerations=risks_and_considerations,
+            testing_approach=testing_approach,
+            success_criteria=success_criteria,
+        )
+    
+    return exit_plan_mode