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

tunacode/cli/commands/implementations/plan.py

@@ -0,0 +1,50 @@
+"""Plan mode commands for TunaCode."""
+
+from typing import List
+
+from ....types import CommandContext
+from ....ui import console as ui
+from ..base import Command, CommandCategory, CommandSpec, SimpleCommand
+
+
+class PlanCommand(SimpleCommand):
+    """Enter plan mode for read-only research and planning."""
+    
+    spec = CommandSpec(
+        name="plan",
+        aliases=["/plan"],
+        description="Enter Plan Mode - read-only research phase",
+        category=CommandCategory.DEVELOPMENT,
+    )
+    
+    async def execute(self, args: List[str], context: CommandContext) -> None:
+        """Enter plan mode."""
+        context.state_manager.enter_plan_mode()
+        
+        await ui.info("🔍 Entering Plan Mode")
+        await ui.info("• Only read-only operations available")
+        await ui.info("• Use tools to research and analyze the codebase")
+        await ui.info("• Use 'exit_plan_mode' tool to present your plan")
+        await ui.info("• Read-only tools: read_file, grep, list_dir, glob")
+        await ui.success("✅ Plan Mode active - indicator will appear above next input")
+
+
+class ExitPlanCommand(SimpleCommand):
+    """Exit plan mode manually."""
+    
+    spec = CommandSpec(
+        name="exit-plan",
+        aliases=["/exit-plan"],
+        description="Exit Plan Mode and return to normal mode",
+        category=CommandCategory.DEVELOPMENT,
+    )
+    
+    async def execute(self, args: List[str], context: CommandContext) -> None:
+        """Exit plan mode manually."""
+        if not context.state_manager.is_plan_mode():
+            await ui.warning("Not currently in Plan Mode")
+            return
+        
+        context.state_manager.exit_plan_mode()
+        await ui.success("🚪 Exiting Plan Mode - returning to normal mode")
+        await ui.info("✅ All tools are now available - '⏸ PLAN MODE ON' status removed")

tunacode/cli/commands/registry.py

@@ -23,6 +23,7 @@ from .implementations.debug import (
 )
 from .implementations.development import BranchCommand, InitCommand
 from .implementations.model import ModelCommand
+from .implementations.plan import ExitPlanCommand, PlanCommand
 from .implementations.system import (
     ClearCommand,
     HelpCommand,
@@ -129,6 +130,8 @@ class CommandRegistry:
             InitCommand,
             TemplateCommand,
             TodoCommand,
+            PlanCommand,        # Add plan command
+            ExitPlanCommand,    # Add exit plan command
         ]
 
         # Register all discovered commands

tunacode/cli/repl.py

@@ -54,6 +54,324 @@ logger = logging.getLogger(__name__)
 # The _tool_handler function has been moved to repl_components.tool_executor
 
 
+def _transform_to_implementation_request(original_request: str) -> str:
+    """
+    Transform a planning request into an implementation request.
+
+    This ensures that after plan approval, the agent understands it should
+    implement rather than plan again.
+    """
+    # Remove plan-related language and add implementation language
+    request = original_request.lower()
+
+    if "plan" in request:
+        # Transform "plan a md file" -> "create a md file"
+        # Transform "plan to implement" -> "implement"
+        request = request.replace("plan a ", "create a ")
+        request = request.replace("plan an ", "create an ")
+        request = request.replace("plan to ", "")
+        request = request.replace("plan ", "create ")
+
+    # Add clear implementation instruction
+    implementation_request = f"{request}\n\nIMPORTANT: Actually implement and create the file(s) - do not just plan or outline. The plan has been approved, now execute the implementation."
+
+    return implementation_request
+
+
+async def _display_plan(plan_doc) -> None:
+    """Display the plan in a formatted way."""
+
+    if not plan_doc:
+        await ui.error("⚠️ Error: No plan document found to display")
+        return
+
+    output = []
+    output.append(f"[bold cyan]🎯 {plan_doc.title}[/bold cyan]")
+    output.append("")
+
+    if plan_doc.overview:
+        output.append(f"[bold]📝 Overview:[/bold] {plan_doc.overview}")
+        output.append("")
+
+    # Files section
+    if plan_doc.files_to_modify:
+        output.append("[bold]📝 Files to Modify:[/bold]")
+        for f in plan_doc.files_to_modify:
+            output.append(f"  • {f}")
+        output.append("")
+
+    if plan_doc.files_to_create:
+        output.append("[bold]📄 Files to Create:[/bold]")
+        for f in plan_doc.files_to_create:
+            output.append(f"  • {f}")
+        output.append("")
+
+    # Implementation steps
+    output.append("[bold]🔧 Implementation Steps:[/bold]")
+    for i, step in enumerate(plan_doc.steps, 1):
+        output.append(f"  {i}. {step}")
+    output.append("")
+
+    # Testing approach
+    if plan_doc.tests:
+        output.append("[bold]🧪 Testing Approach:[/bold]")
+        for test in plan_doc.tests:
+            output.append(f"  • {test}")
+        output.append("")
+
+    # Success criteria
+    if plan_doc.success_criteria:
+        output.append("[bold]✅ Success Criteria:[/bold]")
+        for criteria in plan_doc.success_criteria:
+            output.append(f"  • {criteria}")
+        output.append("")
+
+    # Risks and considerations
+    if plan_doc.risks:
+        output.append("[bold]⚠️ Risks & Considerations:[/bold]")
+        for risk in plan_doc.risks:
+            output.append(f"  • {risk}")
+        output.append("")
+
+    # Open questions
+    if plan_doc.open_questions:
+        output.append("[bold]❓ Open Questions:[/bold]")
+        for question in plan_doc.open_questions:
+            output.append(f"  • {question}")
+        output.append("")
+
+    # References
+    if plan_doc.references:
+        output.append("[bold]📚 References:[/bold]")
+        for ref in plan_doc.references:
+            output.append(f"  • {ref}")
+        output.append("")
+
+    # Rollback plan
+    if plan_doc.rollback:
+        output.append(f"[bold]🔄 Rollback Plan:[/bold] {plan_doc.rollback}")
+        output.append("")
+
+    # Display the plan in a cyan panel
+    await ui.panel("📋 IMPLEMENTATION PLAN", "\n".join(output), border_style="cyan")
+
+
+async def _detect_and_handle_text_plan(state_manager, agent_response, original_request):
+    """
+    Detect if agent presented a plan in text format and handle it.
+
+    This is a fallback for when agents ignore the present_plan tool requirement.
+    """
+    try:
+        # Extract response text
+        response_text = ""
+        if hasattr(agent_response, 'messages') and agent_response.messages:
+            latest_msg = agent_response.messages[-1]
+            if hasattr(latest_msg, 'content'):
+                response_text = str(latest_msg.content)
+            elif hasattr(latest_msg, 'text'):
+                response_text = str(latest_msg.text)
+        elif hasattr(agent_response, 'result') and hasattr(agent_response.result, 'output'):
+            response_text = str(agent_response.result.output)
+        else:
+            response_text = str(agent_response)
+
+        # Skip if agent just returned TUNACODE_TASK_COMPLETE or showed present_plan as text
+        if "TUNACODE_TASK_COMPLETE" in response_text:
+            logger.debug("Agent returned TUNACODE_TASK_COMPLETE instead of calling present_plan")
+            await ui.warning("⚠️ Agent failed to call present_plan tool. Please provide clearer instructions to plan the task.")
+            return
+
+        if "present_plan(" in response_text:
+            logger.debug("Agent showed present_plan as text instead of executing it")
+            await ui.error("❌ Agent showed present_plan as text instead of EXECUTING it as a tool!")
+            await ui.info("The agent must EXECUTE the present_plan tool, not show it as code.")
+            await ui.info("Try again with: 'Execute the present_plan tool to create a plan for...'")
+            return
+
+        # Check for plan indicators
+        plan_indicators = [
+            "plan for", "implementation plan", "here's a plan", "i'll create a plan",
+            "plan to write", "plan to create", "markdown file", "outline for the",
+            "plan title", "overview:", "steps:", "file title and introduction",
+            "main functions", "sections to cover", "structure for", "plan overview"
+        ]
+
+        has_plan_indicators = any(indicator in response_text.lower() for indicator in plan_indicators)
+
+        # Also check for structured content (numbered lists, bullet points, sections)
+        has_structure = bool(
+            ("1." in response_text or "2." in response_text or "3." in response_text) or
+            ("•" in response_text and response_text.count("•") >= 3) or
+            ("Title:" in response_text and "Overview:" in response_text)
+        )
+
+        if has_plan_indicators and has_structure:
+            # Agent presented a text plan - simulate the approval flow
+            await ui.line()
+            await ui.info("📋 Plan detected in text format - extracting for review")
+
+            # Create a simple plan from the text
+            from tunacode.types import PlanDoc, PlanPhase
+
+            # Extract title (simple heuristic)
+            title = "TunaCode Functions Overview Markdown File"
+            if "title:" in response_text.lower():
+                lines = response_text.split("\n")
+                for line in lines:
+                    if "title:" in line.lower():
+                        title = line.split(":", 1)[1].strip().strip('"')
+                        break
+
+            # Create basic plan structure from detected text
+            plan_doc = PlanDoc(
+                title=title,
+                overview="Create a comprehensive markdown file documenting TunaCode's main functions",
+                steps=[
+                    "Draft document structure with sections",
+                    "Detail each function with descriptions and examples",
+                    "Add usage guidelines and best practices",
+                    "Review and finalize content"
+                ],
+                files_to_modify=[],
+                files_to_create=["TunaCode_Functions_Overview.md"],
+                success_criteria=["Clear documentation of all main TunaCode functions"]
+            )
+
+            # Set plan ready state and trigger approval
+            state_manager.session.plan_phase = PlanPhase.PLAN_READY
+            state_manager.session.current_plan = plan_doc
+
+            await _handle_plan_approval(state_manager, original_request)
+
+    except Exception as e:
+        logger.error(f"Error detecting text plan: {e}")
+        # If detection fails, just continue normally
+
+
+async def _handle_plan_approval(state_manager, original_request=None):
+    """
+    Handle plan approval when a plan has been presented via present_plan tool.
+
+    This function:
+    1. Shows the user approval options (approve/modify/reject)
+    2. Handles the user's decision appropriately
+    3. Continues with implementation if approved
+    """
+    try:
+        from tunacode.types import PlanPhase
+
+        # Exit plan mode and move to review phase
+        state_manager.session.plan_phase = PlanPhase.REVIEW_DECISION
+        plan_doc = state_manager.session.current_plan
+        state_manager.exit_plan_mode(plan_doc)
+
+        await ui.line()
+        await ui.info("📋 Plan has been prepared and Plan Mode exited")
+        await ui.line()
+
+        # Display the plan content now
+        await _display_plan(plan_doc)
+
+        # Display approval options with better styling
+        await ui.line()
+        # Create content with exactly 45 characters per line for perfect alignment
+        content = (
+            "[bold cyan]The implementation plan has been presented.  [/bold cyan]\n\n"
+            "[yellow]Choose your action:                          [/yellow]\n\n"
+            "  [bold green]a[/bold green] → Approve and proceed with implementation\n"
+            "  [bold yellow]m[/bold yellow] → Modify the plan (return to Plan Mode)  \n"
+            "  [bold red]r[/bold red] → Reject and create different approach   \n"
+        )
+        await ui.panel("🎯 Plan Review", content, border_style="cyan")
+        await ui.line()
+
+        # Handle double-escape pattern like main REPL
+        from tunacode.ui.keybindings import create_key_bindings
+        kb = create_key_bindings(state_manager)
+
+        while True:
+            try:
+                response = await ui.input(
+                    session_key="plan_approval",
+                    pretext="  → Your choice [a/m/r]: ",
+                    key_bindings=kb,
+                    state_manager=state_manager
+                )
+                response = response.strip().lower()
+
+                # Reset abort flags on successful input
+                state_manager.session.approval_abort_pressed = False
+                state_manager.session.approval_last_abort_time = 0.0
+                break
+
+            except UserAbortError:
+                import time
+                current_time = time.time()
+
+                # Get current session state
+                approval_abort_pressed = getattr(state_manager.session, 'approval_abort_pressed', False)
+                approval_last_abort_time = getattr(state_manager.session, 'approval_last_abort_time', 0.0)
+
+                # Reset if more than 3 seconds have passed
+                if current_time - approval_last_abort_time > 3.0:
+                    approval_abort_pressed = False
+                    state_manager.session.approval_abort_pressed = False
+
+                if approval_abort_pressed:
+                    # Second escape - return to Plan Mode
+                    await ui.line()
+                    await ui.info("🔄 Returning to Plan Mode for further planning")
+                    await ui.line()
+                    state_manager.enter_plan_mode()
+                    # Clean up approval flags
+                    state_manager.session.approval_abort_pressed = False
+                    state_manager.session.approval_last_abort_time = 0.0
+                    return
+
+                # First escape - show warning and continue the loop
+                state_manager.session.approval_abort_pressed = True
+                state_manager.session.approval_last_abort_time = current_time
+                await ui.line()
+                await ui.warning("Hit ESC or Ctrl+C again to return to Plan Mode")
+                await ui.line()
+                continue
+
+        if response in ['a', 'approve']:
+            await ui.line()
+            await ui.success("✅ Plan approved - proceeding with implementation")
+            state_manager.approve_plan()
+            state_manager.session.plan_phase = None
+
+            # Continue processing the original request now that we're in normal mode
+            if original_request:
+                await ui.info("🚀 Executing implementation...")
+                await ui.line()
+                # Transform the original request to make it clear we want implementation, not more planning
+                implementation_request = _transform_to_implementation_request(original_request)
+                await process_request(implementation_request, state_manager, output=True)
+
+        elif response in ['m', 'modify']:
+            await ui.line()
+            await ui.info("📝 Returning to Plan Mode for modifications")
+            state_manager.enter_plan_mode()
+
+        elif response in ['r', 'reject']:
+            await ui.line()
+            await ui.warning("🔄 Plan rejected - returning to Plan Mode")
+            state_manager.enter_plan_mode()
+
+        else:
+            await ui.line()
+            await ui.warning("⚠️ Invalid choice - please enter a, m, or r")
+            state_manager.session.plan_phase = None
+
+    except Exception as e:
+        logger.error(f"Error in plan approval: {e}")
+        # If anything goes wrong, reset plan phase
+        state_manager.session.plan_phase = None
+
+
 # ============================================================================
 # COMMAND SYSTEM
 # ============================================================================
@@ -177,6 +495,14 @@ async def process_request(text: str, state_manager: StateManager, output: bool =
                 await streaming_panel.stop()
                 state_manager.session.streaming_panel = None
                 state_manager.session.is_streaming_active = False
+
+            # Check if plan is ready for user review OR if agent presented text plan
+            from tunacode.types import PlanPhase
+            if hasattr(state_manager.session, 'plan_phase') and state_manager.session.plan_phase == PlanPhase.PLAN_READY:
+                await _handle_plan_approval(state_manager, text)
+            elif state_manager.is_plan_mode() and not getattr(state_manager.session, '_continuing_from_plan', False):
+                # Check if agent presented a text plan instead of using the tool
+                await _detect_and_handle_text_plan(state_manager, res, text)
         else:
             # Use normal agent processing
             res = await agent.process_request(
@@ -186,6 +512,14 @@ async def process_request(text: str, state_manager: StateManager, output: bool =
                 tool_callback=tool_callback_with_state,
             )
 
+        # Check if plan is ready for user review OR if agent presented text plan
+        from tunacode.types import PlanPhase
+        if hasattr(state_manager.session, 'plan_phase') and state_manager.session.plan_phase == PlanPhase.PLAN_READY:
+            await _handle_plan_approval(state_manager, text)
+        elif state_manager.is_plan_mode() and not getattr(state_manager.session, '_continuing_from_plan', False):
+            # Check if agent presented a text plan instead of using the tool
+            await _detect_and_handle_text_plan(state_manager, res, text)
+
         if output:
             if state_manager.session.show_thoughts:
                 new_msgs = state_manager.session.messages[start_idx:]
@@ -205,7 +539,7 @@ async def process_request(text: str, state_manager: StateManager, output: bool =
                 await ui.muted(MSG_REQUEST_COMPLETED)
             else:
                 # Use the dedicated function for displaying agent output
-                await display_agent_output(res, enable_streaming)
+                await display_agent_output(res, enable_streaming, state_manager)
 
             # Always show files in context after agent response
             if state_manager.session.files_in_context:

tunacode/cli/repl_components/output_display.py

@@ -10,7 +10,7 @@ from tunacode.ui import console as ui
 MSG_REQUEST_COMPLETED = "Request completed"
 
 
-async def display_agent_output(res, enable_streaming: bool) -> None:
+async def display_agent_output(res, enable_streaming: bool, state_manager=None) -> None:
     """Display agent output using guard clauses to flatten nested conditionals."""
     if enable_streaming:
         return
@@ -29,5 +29,22 @@ async def display_agent_output(res, enable_streaming: bool) -> None:
 
     if '"tool_uses"' in output:
         return
+    
+    # In plan mode, don't display any agent text output at all
+    # The plan will be displayed via the present_plan tool
+    if state_manager and state_manager.is_plan_mode():
+        return
+    
+    # Filter out plan mode system prompts and tool definitions
+    if any(phrase in output for phrase in [
+        "PLAN MODE - TOOL EXECUTION ONLY",
+        "🔧 PLAN MODE",
+        "TOOL EXECUTION ONLY 🔧",
+        "planning assistant that ONLY communicates",
+        "namespace functions {",
+        "namespace multi_tool_use {",
+        "You are trained on data up to"
+    ]):
+        return
 
     await ui.agent(output)

tunacode/cli/repl_components/tool_executor.py

@@ -59,6 +59,15 @@ async def tool_handler(part, state_manager: StateManager):
         args = parse_args(part.args)
 
         def confirm_func():
+            # Check if tool is blocked in plan mode first
+            if tool_handler_instance.is_tool_blocked_in_plan_mode(part.tool_name):
+                from tunacode.constants import READ_ONLY_TOOLS
+                error_msg = (f"🔍 Plan Mode: Tool '{part.tool_name}' is not available in Plan Mode.\n"
+                           f"Only read-only tools are allowed: {', '.join(READ_ONLY_TOOLS)}\n"
+                           f"Use 'exit_plan_mode' tool to present your plan and exit Plan Mode.")
+                print(f"\n❌ {error_msg}\n")
+                return True  # Abort the tool
+            
             if not tool_handler_instance.should_confirm(part.tool_name):
                 return False
             request = tool_handler_instance.create_confirmation_request(part.tool_name, args)

tunacode/constants.py

@@ -9,7 +9,7 @@ from enum import Enum
 
 # Application info
 APP_NAME = "TunaCode"
-APP_VERSION = "0.0.55"
+APP_VERSION = "0.0.56"
 
 
 # File patterns
@@ -44,6 +44,7 @@ class ToolName(str, Enum):
     LIST_DIR = "list_dir"
     GLOB = "glob"
     TODO = "todo"
+    EXIT_PLAN_MODE = "exit_plan_mode"
 
 
 # Tool names (backward compatibility)
@@ -56,9 +57,10 @@ TOOL_GREP = ToolName.GREP
 TOOL_LIST_DIR = ToolName.LIST_DIR
 TOOL_GLOB = ToolName.GLOB
 TOOL_TODO = ToolName.TODO
+TOOL_EXIT_PLAN_MODE = ToolName.EXIT_PLAN_MODE
 
 # Tool categorization
-READ_ONLY_TOOLS = [ToolName.READ_FILE, ToolName.GREP, ToolName.LIST_DIR, ToolName.GLOB]
+READ_ONLY_TOOLS = [ToolName.READ_FILE, ToolName.GREP, ToolName.LIST_DIR, ToolName.GLOB, ToolName.EXIT_PLAN_MODE]
 WRITE_TOOLS = [ToolName.WRITE_FILE, ToolName.UPDATE_FILE]
 EXECUTE_TOOLS = [ToolName.BASH, ToolName.RUN_COMMAND]