tunacode-cli 0.0.55__tar.gz → 0.0.56__tar.gz

{tunacode_cli-0.0.55 → tunacode_cli-0.0.56}/CLAUDE.md

@@ -2,8 +2,7 @@
 
 - update the documents @documentation and in .claude after any update.
 
-
--  use the subagent tech-docs-maintainer to update the documentation you MUST instruct the subagent to keep doc updates short you will be PUNISHED for not telling the documentation agent to keep it to only the most distilled information
+- use the subagent tech-docs-maintainer to update the documentation you MUST instruct the subagent to keep doc updates short you will be PUNISHED for not telling the documentation agent to keep it to only the most distilled information
 
 - always follow best practices with git commits naming and gh cli workflows
 
@@ -13,6 +12,7 @@
 
 ### Python Coding Standards
 
+- always use the venv
 - Use type hints (PEP 484) for all function signatures
 - Prefer f-strings (PEP 498) over %-formatting or .format()
 - Use pathlib.Path instead of os.path for filesystem operations

{tunacode_cli-0.0.55/src/tunacode_cli.egg-info → tunacode_cli-0.0.56}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tunacode-cli
-Version: 0.0.55
+Version: 0.0.56
 Summary: Your agentic CLI developer.
 Author-email: larock22 <noreply@github.com>
 License: MIT
@@ -39,6 +39,7 @@ Requires-Dist: vulture>=2.7; extra == "dev"
 Requires-Dist: unimport>=1.0.0; extra == "dev"
 Requires-Dist: autoflake>=2.0.0; extra == "dev"
 Requires-Dist: dead>=1.5.0; extra == "dev"
+Requires-Dist: hatch>=1.6.0; extra == "dev"
 Dynamic: license-file
 
 # TunaCode CLI
@@ -106,7 +107,7 @@ tunacode --model "anthropic:claude-3.5-sonnet" --key "sk-ant-your-anthropic-key"
 tunacode --model "openrouter:openai/gpt-4o" --key "sk-or-your-openrouter-key"
 ```
 
-Your config is saved to `~/.config/tunacode.json` (edit directly with `nvim ~/.config/tunacode.json`)
+Your config is saved to `~/.config/tunacode.json`. This file stores your API keys, model preferences, and runtime settings like `max_iterations` (default: 40) and `context_window_size`. You can edit it directly with `nvim ~/.config/tunacode.json` or see [the complete configuration example](documentation/configuration/config-file-example.md) for all available options.
 
 ### Recommended Models
 
@@ -243,7 +244,7 @@ tunacode --model "anthropic:claude-3.5-sonnet" --key "sk-ant-your-anthropic-key"
 tunacode --model "openrouter:openai/gpt-4o" --key "sk-or-your-openrouter-key"
 ```
 
-Your config is saved to `~/.config/tunacode.json` (edit directly with `nvim ~/.config/tunacode.json`)
+Your config is saved to `~/.config/tunacode.json`. This file stores your API keys, model preferences, and runtime settings like `max_iterations` (default: 40) and `context_window_size`. You can edit it directly with `nvim ~/.config/tunacode.json` or see [the complete configuration example](documentation/configuration/config-file-example.md) for all available options.
 
 ### Recommended Models
 

{tunacode_cli-0.0.55 → tunacode_cli-0.0.56}/README.md

@@ -63,7 +63,7 @@ tunacode --model "anthropic:claude-3.5-sonnet" --key "sk-ant-your-anthropic-key"
 tunacode --model "openrouter:openai/gpt-4o" --key "sk-or-your-openrouter-key"
 ```
 
-Your config is saved to `~/.config/tunacode.json` (edit directly with `nvim ~/.config/tunacode.json`)
+Your config is saved to `~/.config/tunacode.json`. This file stores your API keys, model preferences, and runtime settings like `max_iterations` (default: 40) and `context_window_size`. You can edit it directly with `nvim ~/.config/tunacode.json` or see [the complete configuration example](documentation/configuration/config-file-example.md) for all available options.
 
 ### Recommended Models
 
@@ -200,7 +200,7 @@ tunacode --model "anthropic:claude-3.5-sonnet" --key "sk-ant-your-anthropic-key"
 tunacode --model "openrouter:openai/gpt-4o" --key "sk-or-your-openrouter-key"
 ```
 
-Your config is saved to `~/.config/tunacode.json` (edit directly with `nvim ~/.config/tunacode.json`)
+Your config is saved to `~/.config/tunacode.json`. This file stores your API keys, model preferences, and runtime settings like `max_iterations` (default: 40) and `context_window_size`. You can edit it directly with `nvim ~/.config/tunacode.json` or see [the complete configuration example](documentation/configuration/config-file-example.md) for all available options.
 
 ### Recommended Models
 

{tunacode_cli-0.0.55 → tunacode_cli-0.0.56}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "setuptools.build_meta"
 [project]
 name = "tunacode-cli"
 
-version = "0.0.55"
+version = "0.0.56"
 description = "Your agentic CLI developer."
 keywords = ["cli", "agent", "development", "automation"]
 readme = "README.md"
@@ -50,6 +50,7 @@ dev = [
     "unimport>=1.0.0",
     "autoflake>=2.0.0",
     "dead>=1.5.0",
+    "hatch>=1.6.0",
 ]
 
 [project.urls]
@@ -146,3 +147,59 @@ warn_no_return = true
 follow_imports = "silent"
 # Allow CLAUDE_ANCHOR comments in docstrings
 disable_error_code = ["annotation-unchecked"]
+
+[tool.hatch.envs.default.scripts]
+# Development
+install = "pip install -e '.[dev]'"
+run = "python -m tunacode"
+test-script = "echo 'Test script works'"
+
+# Cleaning
+clean = "python -c \"import shutil, pathlib; dirs=['build', 'dist']; [shutil.rmtree(d, ignore_errors=True) for d in dirs]; [shutil.rmtree(p, ignore_errors=True) for p in pathlib.Path('.').rglob('*.egg-info') if p.is_dir()]; [shutil.rmtree(p, ignore_errors=True) for p in pathlib.Path('.').rglob('__pycache__') if p.is_dir()]; [p.unlink(missing_ok=True) for p in pathlib.Path('.').rglob('*.pyc')]; print('Cleaned build artifacts, egg-info, __pycache__, and *.pyc files')\""
+
+# Linting & Formatting
+lint = "ruff check . && ruff format ."
+lint-check = [
+    "ruff check .",
+    "ruff format --check .",
+]
+
+# Dead code analysis
+vulture = "python -m vulture --config pyproject.toml"
+vulture-check = "python -m vulture --config pyproject.toml --min-confidence 100"
+
+dead-code-check = [
+    "python -c \"print('Running comprehensive dead code analysis...')\"",
+    "python -c \"print('\\n=== Vulture (unused code) ===')\"",
+    "python -m vulture . --min-confidence 80 --exclude '*/test/*,*/tests/*,venv/*,build/*,dist/*' || true",
+    "python -c \"print('\\n=== Unimport (unused imports) ===')\"",
+    "python -m unimport --check . || true",
+    "python -c \"print('\\n=== Dead (dead code detector) ===')\"",
+    "python -m dead . || true",
+    "python -c \"print('\\n=== Checking test coverage for dead code ===')\"",
+]
+
+dead-code-clean = [
+    "python -c \"print('Removing dead code...')\"",
+    "python -m unimport --remove-all .",
+    "python -m autoflake --remove-all-unused-imports --remove-unused-variables -i -r src/",
+    "python -c \"print('Dead code cleanup complete!')\"",
+]
+
+dead-code-report = [
+    "python -c \"print('Generating dead code reports...'); import pathlib; pathlib.Path('reports').mkdir(exist_ok=True)\"",
+    "python -m vulture . --min-confidence 60 > reports/dead_code_vulture.txt || true",
+    "python -m unimport --check . --diff > reports/unused_imports.txt || true",
+    "python -c \"print('Reports generated in reports/ directory')\"",
+]
+
+# Testing
+test = "python -m pytest -q tests/characterization tests/test_security.py tests/test_agent_output_formatting.py tests/test_prompt_changes_validation.py"
+coverage = "pytest --cov=src/tunacode --cov-report=term"
+
+# Building
+build = "python -m build"
+
+# Playwright utilities
+remove-playwright = "python scripts/playwright_cache.py remove"
+restore-playwright = "python scripts/playwright_cache.py restore"

tunacode_cli-0.0.56/src/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-0.0.55 → tunacode_cli-0.0.56}/src/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-0.0.55 → tunacode_cli-0.0.56}/src/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-0.0.55 → tunacode_cli-0.0.56}/src/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-0.0.55 → tunacode_cli-0.0.56}/src/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_cli-0.0.55 → tunacode_cli-0.0.56}/src/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]