tunacode-cli 0.0.70__py3-none-any.whl → 0.0.78.6__py3-none-any.whl

tunacode/cli/repl.py

@@ -13,8 +13,8 @@ from pydantic_ai.exceptions import UnexpectedModelBehavior
 
 from tunacode.configuration.models import ModelRegistry
 from tunacode.constants import DEFAULT_CONTEXT_WINDOW
-from tunacode.core.agents import main as agent
-from tunacode.core.agents.main import patch_tool_messages
+from tunacode.core import agents as agent
+from tunacode.core.agents import patch_tool_messages
 from tunacode.core.token_usage.api_response_parser import ApiResponseParser
 from tunacode.core.token_usage.cost_calculator import CostCalculator
 from tunacode.core.token_usage.usage_tracker import UsageTracker
@@ -41,237 +41,69 @@ DEFAULT_SHELL = "bash"
 logger = logging.getLogger(__name__)
 
 
-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.
-    """
-    request = original_request.lower()
-
-    if "plan" in request:
-        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 = [f"[bold cyan]🎯 {plan_doc.title}[/bold cyan]", ""]
-
-    if plan_doc.overview:
-        output.extend([f"[bold]📝 Overview:[/bold] {plan_doc.overview}", ""])
-
-    sections = [
-        ("📝 Files to Modify:", plan_doc.files_to_modify, "•"),
-        ("📄 Files to Create:", plan_doc.files_to_create, "•"),
-        ("🧪 Testing Approach:", plan_doc.tests, "•"),
-        ("✅ Success Criteria:", plan_doc.success_criteria, "•"),
-        ("⚠️ Risks & Considerations:", plan_doc.risks, "•"),
-        ("❓ Open Questions:", plan_doc.open_questions, "•"),
-        ("📚 References:", plan_doc.references, "•"),
-    ]
-
-    for title, items, prefix in sections:
-        if items:
-            output.append(f"[bold]{title}[/bold]")
-            output.extend(f"  {prefix} {item}" for item in items)
-            output.append("")
-
-    output.append("[bold]🔧 Implementation Steps:[/bold]")
-    output.extend(f"  {i}. {step}" for i, step in enumerate(plan_doc.steps, 1))
-    output.append("")
-
-    if plan_doc.rollback:
-        output.extend([f"[bold]🔄 Rollback Plan:[/bold] {plan_doc.rollback}", ""])
-
-    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."""
-    try:
-        # Extract response text
-        response_text = ""
-        if hasattr(agent_response, "messages") and agent_response.messages:
-            msg = agent_response.messages[-1]
-            response_text = str(getattr(msg, "content", getattr(msg, "text", msg)))
-        elif hasattr(agent_response, "result"):
-            response_text = str(getattr(agent_response.result, "output", agent_response.result))
-        else:
-            response_text = str(agent_response)
-
-        if "TUNACODE_TASK_COMPLETE" in response_text:
-            await ui.warning(
-                "⚠️ Agent failed to call present_plan tool. Please provide clearer instructions."
-            )
-            return
-
-        if "present_plan(" in response_text:
-            await ui.error(
-                "❌ Agent showed present_plan as text instead of EXECUTING it as a tool!"
-            )
-            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",
-            "outline for",
-            "overview:",
-            "steps:",
-        }
-        has_plan = any(ind in response_text.lower() for ind in plan_indicators)
-        has_structure = (
-            any(x in response_text for x in ["1.", "2.", "•"]) and response_text.count("\n") > 5
-        )
-
-        if has_plan and has_structure:
-            await ui.info("📋 Plan detected in text format - extracting for review")
-            from tunacode.types import PlanDoc, PlanPhase
-
-            plan_doc = PlanDoc(
-                title="Implementation Plan",
-                overview="Automated plan extraction from text",
-                steps=["Review and implement the described functionality"],
-                files_to_modify=[],
-                files_to_create=[],
-                success_criteria=[],
-            )
-
-            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}")
+_command_registry = CommandRegistry()
+_command_registry.register_all_default_commands()
 
 
-async def _handle_plan_approval(state_manager, original_request=None):
-    """Handle plan approval when a plan has been presented via present_plan tool."""
+async def _handle_command(command: str, state_manager: StateManager) -> CommandResult:
+    """Handles a command string using the command registry."""
+    context = CommandContext(state_manager=state_manager, process_request=execute_repl_request)
     try:
-        import time
-
-        from tunacode.types import PlanPhase
-        from tunacode.ui.keybindings import create_key_bindings
-
-        state_manager.session.plan_phase = PlanPhase.REVIEW_DECISION
-        plan_doc = state_manager.session.current_plan
-        state_manager.exit_plan_mode(plan_doc)
+        _command_registry.set_process_request_callback(execute_repl_request)
+        return await _command_registry.execute(command, context)
+    except ValidationError as e:
+        await ui.error(str(e))
+        return None
 
-        await ui.info("📋 Plan has been prepared and Plan Mode exited")
-        await _display_plan(plan_doc)
 
-        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\n"
-            "  [bold yellow]m[/bold yellow] → Modify the plan\n"
-            "  [bold red]r[/bold red] → Reject and recreate\n"
-        )
-        await ui.panel("🎯 Plan Review", content, border_style="cyan")
+def _extract_feedback_from_last_message(state_manager: StateManager) -> str | None:
+    """Extract user guidance feedback from recent messages in session.messages.
 
-        kb = create_key_bindings(state_manager)
-        while True:
-            try:
-                response = await ui.input(
-                    "plan_approval", "  → Your choice [a/m/r]: ", kb, state_manager
-                )
-                response = response.strip().lower()
-                state_manager.session.approval_abort_pressed = False
-                state_manager.session.approval_last_abort_time = 0.0
-                break
-            except UserAbortError:
-                current_time = time.time()
-                abort_pressed = getattr(state_manager.session, "approval_abort_pressed", False)
-                last_abort = getattr(state_manager.session, "approval_last_abort_time", 0.0)
+    When option 3 is selected with feedback, a message is added with format:
+    "Tool '...' execution cancelled before running.\nUser guidance:\n{guidance}\n..."
 
-                if current_time - last_abort > 3.0:
-                    abort_pressed = False
+    Note: patch_tool_messages() adds "Operation aborted by user." AFTER the feedback,
+    so we check the last few messages, not just the last one.
 
-                if abort_pressed:
-                    await ui.info("🔄 Returning to Plan Mode")
-                    state_manager.enter_plan_mode()
-                    state_manager.session.approval_abort_pressed = False
-                    return
-
-                state_manager.session.approval_abort_pressed = True
-                state_manager.session.approval_last_abort_time = current_time
-                await ui.warning("Hit ESC or Ctrl+C again to return to Plan Mode")
-
-        actions = {
-            "a": (
-                "✅ Plan approved - proceeding with implementation",
-                lambda: state_manager.approve_plan(),
-            ),
-            "m": (
-                "📝 Returning to Plan Mode for modifications",
-                lambda: state_manager.enter_plan_mode(),
-            ),
-            "r": (
-                "🔄 Plan rejected - returning to Plan Mode",
-                lambda: state_manager.enter_plan_mode(),
-            ),
-        }
-
-        if response in actions or response in ["approve", "modify", "reject"]:
-            key = response[0] if len(response) > 1 else response
-            msg, action = actions.get(key, (None, None))
-            if msg:
-                await ui.info(msg) if key == "a" else await ui.warning(msg)
-                action()
-                if key == "a" and original_request:
-                    await ui.info("🚀 Executing implementation...")
-                    await process_request(
-                        _transform_to_implementation_request(original_request),
-                        state_manager,
-                        output=True,
-                    )
-        else:
-            await ui.warning("⚠️ Invalid choice - please enter a, m, or r")
+    Args:
+        state_manager: State manager containing session messages
 
-        state_manager.session.plan_phase = None
+    Returns:
+        The guidance text if found, None otherwise
+    """
+    if not state_manager.session.messages:
+        return None
 
-    except Exception as e:
-        logger.error(f"Error in plan approval: {e}")
-        state_manager.session.plan_phase = None
+    # Check last 3 messages since patch_tool_messages() adds a message after feedback
+    messages_to_check = state_manager.session.messages[-3:]
 
+    for msg in reversed(messages_to_check):
+        # Extract content from message parts
+        if not hasattr(msg, "parts"):
+            continue
 
-_command_registry = CommandRegistry()
-_command_registry.register_all_default_commands()
+        for part in msg.parts:
+            if hasattr(part, "content") and isinstance(part.content, str):
+                content = part.content
 
+                # Look for "User guidance:" pattern
+                if "User guidance:" in content:
+                    lines = content.split("\n")
+                    for i, line in enumerate(lines):
+                        if "User guidance:" in line and i + 1 < len(lines):
+                            guidance = lines[i + 1].strip()
+                            # Only return non-empty guidance
+                            cancelled_msg = "User cancelled without additional instructions."
+                            if guidance and guidance != cancelled_msg:
+                                return guidance
 
-async def _handle_command(command: str, state_manager: StateManager) -> CommandResult:
-    """Handles a command string using the command registry."""
-    context = CommandContext(state_manager=state_manager, process_request=process_request)
-    try:
-        _command_registry.set_process_request_callback(process_request)
-        return await _command_registry.execute(command, context)
-    except ValidationError as e:
-        await ui.error(str(e))
-        return None
+    return None
 
 
-async def process_request(text: str, state_manager: StateManager, output: bool = True):
+async def execute_repl_request(text: str, state_manager: StateManager, output: bool = True):
     """Process input using the agent, handling cancellation safely."""
     import uuid
 
-    from tunacode.types import PlanPhase
     from tunacode.utils.text_utils import expand_file_refs
 
     state_manager.session.request_id = str(uuid.uuid4())
@@ -319,7 +151,9 @@ async def process_request(text: str, state_manager: StateManager, output: bool =
         if enable_streaming:
             await ui.spinner(False, state_manager.session.spinner, state_manager)
             state_manager.session.is_streaming_active = True
-            streaming_panel = ui.StreamingAgentPanel()
+            streaming_panel = ui.StreamingAgentPanel(
+                debug=bool(state_manager.session.show_thoughts)
+            )
             await streaming_panel.start()
             state_manager.session.streaming_panel = streaming_panel
 
@@ -336,6 +170,20 @@ 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
+                # Emit source-side streaming diagnostics if thoughts are enabled
+                if state_manager.session.show_thoughts:
+                    try:
+                        raw = getattr(state_manager.session, "_debug_raw_stream_accum", "") or ""
+                        events = getattr(state_manager.session, "_debug_events", []) or []
+                        raw_first5 = repr(raw[:5])
+                        await ui.muted(
+                            f"[debug] raw_stream_first5={raw_first5} total_len={len(raw)}"
+                        )
+                        for line in events:
+                            await ui.muted(line)
+                    except Exception:
+                        # Don't let diagnostics break normal flow
+                        pass
         else:
             res = await agent.process_request(
                 text,
@@ -345,17 +193,6 @@ async def process_request(text: str, state_manager: StateManager, output: bool =
                 usage_tracker=usage_tracker,
             )
 
-        # Handle plan approval or detection
-        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
-        ):
-            await _detect_and_handle_text_plan(state_manager, res, text)
-
         if output:
             if state_manager.session.show_thoughts:
                 for msg in state_manager.session.messages[start_idx:]:
@@ -377,7 +214,24 @@ async def process_request(text: str, state_manager: StateManager, output: bool =
     except CancelledError:
         await ui.muted(MSG_REQUEST_CANCELLED)
     except UserAbortError:
-        await ui.muted(MSG_OPERATION_ABORTED)
+        # CLAUDE_ANCHOR[7b2c1d4e]: Guided aborts inject user instructions; skip legacy banner.
+        # Check if there's feedback to process immediately
+        feedback = _extract_feedback_from_last_message(state_manager)
+        if feedback:
+            # Process the feedback as a new request immediately
+            # Stop spinner first to clean up state before recursive call
+            await ui.spinner(False, state_manager.session.spinner, state_manager)
+            # Clear current_task so recursive call can set its own
+            state_manager.session.current_task = None
+            try:
+                await execute_repl_request(feedback, state_manager, output=output)
+            except Exception:
+                # If recursive call fails, don't let it bubble up - just continue
+                pass
+            # Return early to skip the finally block's cleanup (already done above)
+            return
+        # No feedback, just abort normally
+        pass
     except UnexpectedModelBehavior as e:
         await ui.muted(str(e))
         patch_tool_messages(str(e), state_manager)
@@ -395,6 +249,10 @@ async def process_request(text: str, state_manager: StateManager, output: bool =
             )
 
 
+# Backwards compatibility: exported name expected by external integrations/tests
+process_request = execute_repl_request
+
+
 async def warm_code_index():
     """Pre-warm the code index in background for faster directory operations."""
     try:
@@ -434,9 +292,12 @@ async def repl(state_manager: StateManager):
         if state_manager.session.session_total_usage:
             session_cost = float(state_manager.session.session_total_usage.get("cost", 0.0) or 0.0)
 
+        # Subtle, unified styling - mostly muted with minimal accent on cost
         await ui.muted(f"• Model: {state_manager.session.current_model} • {context}")
         if session_cost > 0:
-            await ui.muted(f"• Session Cost: ${session_cost:.4f}")
+            await ui.print(
+                f"[dim]• Session Cost:[/dim] [dim #00d7ff]${session_cost:.4f}[/dim #00d7ff]"
+            )
 
     # Always show context
     await show_context()
@@ -516,7 +377,7 @@ async def repl(state_manager: StateManager):
                 state_manager.session.operation_cancelled = False
 
             state_manager.session.current_task = get_app().create_background_task(
-                process_request(line, state_manager)
+                execute_repl_request(line, state_manager)
             )
             await state_manager.session.current_task
 

tunacode/cli/repl_components/command_parser.py

@@ -31,7 +31,8 @@ def parse_args(args) -> ToolArgs:
         dict: The parsed arguments.
 
     Raises:
-        ValidationError: If 'args' is not a string or dictionary, or if the string is not valid JSON.
+        ValidationError: If 'args' is not a string or dictionary, or if the string
+        is not valid JSON.
     """
     if isinstance(args, str):
         try:

tunacode/cli/repl_components/error_recovery.py

@@ -6,6 +6,7 @@ Error recovery utilities for the REPL.
 
 import logging
 
+import tunacode.core.agents as agent_api
 from tunacode.types import StateManager
 from tunacode.ui import console as ui
 
@@ -64,7 +65,8 @@ async def attempt_json_args_recovery(e: Exception, state_manager: StateManager)
 
                             await ui.warning(f"Warning: {MSG_JSON_ARGS_RECOVERY}")
                             logger.info(
-                                f"Successfully recovered tool {part.tool_name} with split JSON args",
+                                f"Successfully recovered tool {part.tool_name} with "
+                                f"split JSON args",
                                 extra={
                                     "original_args": part.args,
                                     "recovered_args": json_objects[0],
@@ -78,7 +80,8 @@ async def attempt_json_args_recovery(e: Exception, state_manager: StateManager)
 
             except Exception as recovery_exc:
                 logger.error(
-                    f"Error during JSON args recovery for tool {getattr(part, 'tool_name', 'unknown')}",
+                    f"Error during JSON args recovery for tool "
+                    f"{getattr(part, 'tool_name', 'unknown')}",
                     exc_info=True,
                     extra={"recovery_exception": str(recovery_exc)},
                 )
@@ -126,17 +129,17 @@ async def attempt_tool_recovery(e: Exception, state_manager: StateManager) -> bo
             },
         )
         await ui.muted(
-            f"⚠️ Model response error. Attempting to recover by parsing tools from text: {str(e)[:100]}..."
+            f"⚠️ Model response error. Attempting to recover by parsing tools "
+            f"from text: {str(e)[:100]}..."
         )
 
         try:
-            from tunacode.core.agents.main import extract_and_execute_tool_calls
 
             def tool_callback_with_state(tool_part, _node):
                 return tool_handler(tool_part, state_manager)
 
             # This function now returns the number of tools found
-            tools_found = await extract_and_execute_tool_calls(
+            tools_found = await agent_api.extract_and_execute_tool_calls(
                 content_to_parse, tool_callback_with_state, state_manager
             )
 

tunacode/cli/repl_components/output_display.py

@@ -30,19 +30,10 @@ async def display_agent_output(res, enable_streaming: bool, state_manager=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
+    # Filter out 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",

tunacode/cli/repl_components/tool_executor.py

@@ -9,7 +9,7 @@ from asyncio.exceptions import CancelledError
 
 from prompt_toolkit.application import run_in_terminal
 
-from tunacode.core.agents.main import patch_tool_messages
+from tunacode.core.agents import patch_tool_messages
 from tunacode.core.tool_handler import ToolHandler
 from tunacode.exceptions import UserAbortError
 from tunacode.types import StateManager
@@ -59,18 +59,6 @@ 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/configuration/defaults.py

@@ -5,7 +5,7 @@ Default configuration values for the TunaCode CLI.
 Provides sensible defaults for user configuration and environment variables.
 """
 
-from tunacode.constants import GUIDE_FILE_NAME, ToolName
+from tunacode.constants import GUIDE_FILE_NAME
 from tunacode.types import UserConfig
 
 DEFAULT_USER_CONFIG: UserConfig = {
@@ -19,7 +19,7 @@ DEFAULT_USER_CONFIG: UserConfig = {
     "settings": {
         "max_retries": 10,
         "max_iterations": 40,
-        "tool_ignore": [ToolName.READ_FILE],
+        "tool_ignore": [],
         "guide_file": GUIDE_FILE_NAME,
         "fallback_response": True,
         "fallback_verbosity": "normal",  # Options: minimal, normal, detailed