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

tunacode/core/agents/main.py

@@ -2,39 +2,9 @@
 
 Main agent functionality and coordination for the TunaCode CLI.
 Handles agent creation, configuration, and request processing.
-"""
-
-# Re-export for backward compatibility
-from tunacode.services.mcp import get_mcp_servers
 
-from .agent_components import (
-    ToolBuffer,
-    check_task_completion,
-    extract_and_execute_tool_calls,
-    get_model_messages,
-    parse_json_tool_calls,
-    patch_tool_messages,
-)
-
-__all__ = [
-    "ToolBuffer",
-    "check_task_completion",
-    "extract_and_execute_tool_calls",
-    "get_model_messages",
-    "parse_json_tool_calls",
-    "patch_tool_messages",
-    "get_mcp_servers",
-    "check_query_satisfaction",
-    "process_request",
-    "get_or_create_agent",
-    "_process_node",
-    "ResponseState",
-    "SimpleResult",
-    "AgentRunWrapper",
-    "AgentRunWithState",
-    "execute_tools_parallel",
-    "get_agent_tool",
-]
+CLAUDE_ANCHOR[main-agent-module]: Primary agent orchestration and lifecycle management
+"""
 
 from typing import TYPE_CHECKING, Awaitable, Callable, Optional
 
@@ -44,6 +14,16 @@ if TYPE_CHECKING:
     from pydantic_ai import Tool  # noqa: F401
 
 from tunacode.core.logging.logger import get_logger
+from tunacode.core.state import StateManager
+from tunacode.exceptions import ToolBatchingJSONError, UserAbortError
+from tunacode.services.mcp import get_mcp_servers
+from tunacode.types import (
+    AgentRun,
+    ModelName,
+    ToolCallback,
+    UsageTrackerProtocol,
+)
+from tunacode.ui.tool_descriptions import get_batch_description
 
 # Import agent components
 from .agent_components import (
@@ -51,9 +31,22 @@ from .agent_components import (
     AgentRunWrapper,
     ResponseState,
     SimpleResult,
+    ToolBuffer,
     _process_node,
+    check_task_completion,
+    create_empty_response_message,
+    create_fallback_response,
+    create_progress_summary,
+    create_user_message,
     execute_tools_parallel,
+    extract_and_execute_tool_calls,
+    format_fallback_output,
+    get_model_messages,
     get_or_create_agent,
+    get_recent_tools_context,
+    get_tool_summary,
+    parse_json_tool_calls,
+    patch_tool_messages,
 )
 
 # Import streaming types with fallback for older versions
@@ -62,63 +55,32 @@ try:
 
     STREAMING_AVAILABLE = True
 except ImportError:
-    # Fallback for older pydantic-ai versions
     PartDeltaEvent = None
     TextPartDelta = None
     STREAMING_AVAILABLE = False
 
-from tunacode.core.state import StateManager
-from tunacode.exceptions import ToolBatchingJSONError, UserAbortError
-from tunacode.types import (
-    AgentRun,
-    FallbackResponse,
-    ModelName,
-    ToolCallback,
-    UsageTrackerProtocol,
-)
-
 # Configure logging
 logger = get_logger(__name__)
 
-# Cache for UserPromptPart class to avoid repeated imports
-_USER_PROMPT_PART_CLASS = None
-
-
-def _get_user_prompt_part_class():
-    """Get UserPromptPart class with caching and fallback for test environment.
-
-    This function follows DRY principle by centralizing the UserPromptPart
-    import logic and caching the result to avoid repeated imports.
-    """
-    global _USER_PROMPT_PART_CLASS
-
-    if _USER_PROMPT_PART_CLASS is not None:
-        return _USER_PROMPT_PART_CLASS
-
-    try:
-        import importlib
-
-        messages = importlib.import_module("pydantic_ai.messages")
-        _USER_PROMPT_PART_CLASS = getattr(messages, "UserPromptPart", None)
-
-        if _USER_PROMPT_PART_CLASS is None:
-            # Fallback for test environment
-            class UserPromptPartFallback:
-                def __init__(self, content, part_kind):
-                    self.content = content
-                    self.part_kind = part_kind
-
-            _USER_PROMPT_PART_CLASS = UserPromptPartFallback
-    except Exception:
-        # Fallback for test environment
-        class UserPromptPartFallback:
-            def __init__(self, content, part_kind):
-                self.content = content
-                self.part_kind = part_kind
-
-        _USER_PROMPT_PART_CLASS = UserPromptPartFallback
-
-    return _USER_PROMPT_PART_CLASS
+__all__ = [
+    "ToolBuffer",
+    "check_task_completion",
+    "extract_and_execute_tool_calls",
+    "get_model_messages",
+    "parse_json_tool_calls",
+    "patch_tool_messages",
+    "get_mcp_servers",
+    "check_query_satisfaction",
+    "process_request",
+    "get_or_create_agent",
+    "_process_node",
+    "ResponseState",
+    "SimpleResult",
+    "AgentRunWrapper",
+    "AgentRunWithState",
+    "execute_tools_parallel",
+    "get_agent_tool",
+]
 
 
 def get_agent_tool() -> tuple[type[Agent], type["Tool"]]:
@@ -134,15 +96,8 @@ async def check_query_satisfaction(
     response: str,
     state_manager: StateManager,
 ) -> bool:
-    """
-    Check if the response satisfies the original query.
-
-    Returns:
-        bool: True if query is satisfied, False otherwise
-    """
-    # For now, always return True to avoid recursive checks
-    # The agent should use TUNACODE_TASK_COMPLETE marker instead
-    return True
+    """Check if the response satisfies the original query."""
+    return True  # Agent uses TUNACODE_TASK_COMPLETE marker
 
 
 async def process_request(
@@ -157,6 +112,8 @@ async def process_request(
     """
     Process a single request to the agent.
 
+    CLAUDE_ANCHOR[process-request-entry]: Main entry point for all agent requests
+
     Args:
         message: The user's request
         model: The model to use
@@ -231,68 +188,21 @@ async def process_request(
                     response_state,
                 )
 
-                # Handle empty response by asking user for help instead of giving up
+                # Handle empty response
                 if empty_response:
-                    # Track consecutive empty responses
                     if not hasattr(state_manager.session, "consecutive_empty_responses"):
                         state_manager.session.consecutive_empty_responses = 0
                     state_manager.session.consecutive_empty_responses += 1
 
-                    # IMMEDIATE AGGRESSIVE INTERVENTION on ANY empty response
                     if state_manager.session.consecutive_empty_responses >= 1:
-                        # Get context about what was happening
-                        last_tools_used = []
-                        if state_manager.session.tool_calls:
-                            for tc in state_manager.session.tool_calls[-3:]:
-                                tool_name = tc.get("tool", "unknown")
-                                tool_args = tc.get("args", {})
-                                tool_desc = tool_name
-                                if tool_name in ["grep", "glob"] and isinstance(tool_args, dict):
-                                    pattern = tool_args.get("pattern", "")
-                                    tool_desc = f"{tool_name}('{pattern}')"
-                                elif tool_name == "read_file" and isinstance(tool_args, dict):
-                                    path = tool_args.get("file_path", tool_args.get("filepath", ""))
-                                    tool_desc = f"{tool_name}('{path}')"
-                                last_tools_used.append(tool_desc)
-
-                        tools_context = (
-                            f"Recent tools: {', '.join(last_tools_used)}"
-                            if last_tools_used
-                            else "No tools used yet"
+                        force_action_content = create_empty_response_message(
+                            message,
+                            empty_reason,
+                            state_manager.session.tool_calls,
+                            i,
+                            state_manager,
                         )
-
-                        # AGGRESSIVE prompt - YOU FAILED, TRY HARDER
-                        force_action_content = f"""FAILURE DETECTED: You returned {"an " + empty_reason if empty_reason != "empty" else "an empty"} response.
-
-This is UNACCEPTABLE. You FAILED to produce output.
-
-Task: {message[:200]}...
-{tools_context}
-Current iteration: {i}
-
-TRY AGAIN RIGHT NOW:
-
-1. If your search returned no results → Try a DIFFERENT search pattern
-2. If you found what you need → Use TUNACODE_TASK_COMPLETE
-3. If you're stuck → EXPLAIN SPECIFICALLY what's blocking you
-4. If you need to explore → Use list_dir or broader searches
-
-YOU MUST PRODUCE REAL OUTPUT IN THIS RESPONSE. NO EXCUSES.
-EXECUTE A TOOL OR PROVIDE SUBSTANTIAL CONTENT.
-DO NOT RETURN ANOTHER EMPTY RESPONSE."""
-
-                        model_request_cls = get_model_messages()[0]
-                        # Get UserPromptPart from the cached helper
-                        UserPromptPart = _get_user_prompt_part_class()
-                        user_prompt_part = UserPromptPart(
-                            content=force_action_content,
-                            part_kind="user-prompt",
-                        )
-                        force_message = model_request_cls(
-                            parts=[user_prompt_part],
-                            kind="request",
-                        )
-                        state_manager.session.messages.append(force_message)
+                        create_user_message(force_action_content, state_manager)
 
                         if state_manager.session.show_thoughts:
                             from tunacode.ui import console as ui
@@ -301,13 +211,13 @@ DO NOT RETURN ANOTHER EMPTY RESPONSE."""
                                 "\n⚠️ EMPTY RESPONSE FAILURE - AGGRESSIVE RETRY TRIGGERED"
                             )
                             await ui.muted(f"   Reason: {empty_reason}")
-                            await ui.muted(f"   Recent tools: {tools_context}")
+                            await ui.muted(
+                                f"   Recent tools: {get_recent_tools_context(state_manager.session.tool_calls)}"
+                            )
                             await ui.muted("   Injecting 'YOU FAILED TRY HARDER' prompt")
 
-                        # Reset counter after aggressive intervention
                         state_manager.session.consecutive_empty_responses = 0
                 else:
-                    # Reset counter on successful response
                     if hasattr(state_manager.session, "consecutive_empty_responses"):
                         state_manager.session.consecutive_empty_responses = 0
 
@@ -347,18 +257,7 @@ You're describing actions but not executing them. You MUST:
 
 NO MORE DESCRIPTIONS. Take ACTION or mark COMPLETE."""
 
-                    model_request_cls = get_model_messages()[0]
-                    # Get UserPromptPart from the cached helper
-                    UserPromptPart = _get_user_prompt_part_class()
-                    user_prompt_part = UserPromptPart(
-                        content=no_progress_content,
-                        part_kind="user-prompt",
-                    )
-                    progress_message = model_request_cls(
-                        parts=[user_prompt_part],
-                        kind="request",
-                    )
-                    state_manager.session.messages.append(progress_message)
+                    create_user_message(no_progress_content, state_manager)
 
                     if state_manager.session.show_thoughts:
                         from tunacode.ui import console as ui
@@ -367,7 +266,6 @@ NO MORE DESCRIPTIONS. Take ACTION or mark COMPLETE."""
                             f"⚠️ NO PROGRESS: {unproductive_iterations} iterations without tool usage"
                         )
 
-                    # Reset counter after intervention
                     unproductive_iterations = 0
 
                 # REMOVED: Recursive satisfaction check that caused empty responses
@@ -386,11 +284,7 @@ NO MORE DESCRIPTIONS. Take ACTION or mark COMPLETE."""
 
                     # Show summary of tools used so far
                     if state_manager.session.tool_calls:
-                        tool_summary: dict[str, int] = {}
-                        for tc in state_manager.session.tool_calls:
-                            tool_name = tc.get("tool", "unknown")
-                            tool_summary[tool_name] = tool_summary.get(tool_name, 0) + 1
-
+                        tool_summary = get_tool_summary(state_manager.session.tool_calls)
                         summary_str = ", ".join(
                             [f"{name}: {count}" for name, count in tool_summary.items()]
                         )
@@ -398,23 +292,7 @@ NO MORE DESCRIPTIONS. Take ACTION or mark COMPLETE."""
 
                 # User clarification: Ask user for guidance when explicitly awaiting
                 if response_state.awaiting_user_guidance:
-                    # Build a progress summary
-                    tool_summary = {}
-                    if state_manager.session.tool_calls:
-                        for tc in state_manager.session.tool_calls:
-                            tool_name = tc.get("tool", "unknown")
-                            tool_summary[tool_name] = tool_summary.get(tool_name, 0) + 1
-
-                    tools_used_str = (
-                        ", ".join([f"{name}: {count}" for name, count in tool_summary.items()])
-                        if tool_summary
-                        else "No tools used yet"
-                    )
-
-                    # Create user message asking for clarification
-                    model_request_cls = get_model_messages()[0]
-                    # Get UserPromptPart from the cached helper
-                    UserPromptPart = _get_user_prompt_part_class()
+                    _, tools_used_str = create_progress_summary(state_manager.session.tool_calls)
 
                     clarification_content = f"""I need clarification to continue.
 
@@ -427,15 +305,7 @@ Progress so far:
 If the task is complete, I should respond with TUNACODE_TASK_COMPLETE.
 Otherwise, please provide specific guidance on what to do next."""
 
-                    user_prompt_part = UserPromptPart(
-                        content=clarification_content,
-                        part_kind="user-prompt",
-                    )
-                    clarification_message = model_request_cls(
-                        parts=[user_prompt_part],
-                        kind="request",
-                    )
-                    state_manager.session.messages.append(clarification_message)
+                    create_user_message(clarification_content, state_manager)
 
                     if state_manager.session.show_thoughts:
                         from tunacode.ui import console as ui
@@ -444,7 +314,6 @@ Otherwise, please provide specific guidance on what to do next."""
                             "\n🤔 SEEKING CLARIFICATION: Asking user for guidance on task progress"
                         )
 
-                    # Mark that we've asked for user guidance
                     response_state.awaiting_user_guidance = True
 
                 # Check if task is explicitly completed
@@ -456,19 +325,8 @@ Otherwise, please provide specific guidance on what to do next."""
                     break
 
                 if i >= max_iterations and not response_state.task_completed:
-                    # Instead of breaking, ask user if they want to continue
-                    # Build progress summary
-                    tool_summary = {}
-                    if state_manager.session.tool_calls:
-                        for tc in state_manager.session.tool_calls:
-                            tool_name = tc.get("tool", "unknown")
-                            tool_summary[tool_name] = tool_summary.get(tool_name, 0) + 1
-
-                    tools_str = (
-                        ", ".join([f"{name}: {count}" for name, count in tool_summary.items()])
-                        if tool_summary
-                        else "No tools used"
-                    )
+                    _, tools_str = create_progress_summary(state_manager.session.tool_calls)
+                    tools_str = tools_str if tools_str != "No tools used yet" else "No tools used"
 
                     extend_content = f"""I've reached the iteration limit ({max_iterations}).
 
@@ -483,19 +341,7 @@ The task appears incomplete. Would you like me to:
 
 Please let me know how to proceed."""
 
-                    # Create user message
-                    model_request_cls = get_model_messages()[0]
-                    # Get UserPromptPart from the cached helper
-                    UserPromptPart = _get_user_prompt_part_class()
-                    user_prompt_part = UserPromptPart(
-                        content=extend_content,
-                        part_kind="user-prompt",
-                    )
-                    extend_message = model_request_cls(
-                        parts=[user_prompt_part],
-                        kind="request",
-                    )
-                    state_manager.session.messages.append(extend_message)
+                    create_user_message(extend_content, state_manager)
 
                     if state_manager.session.show_thoughts:
                         from tunacode.ui import console as ui
@@ -504,8 +350,7 @@ Please let me know how to proceed."""
                             f"\n📊 ITERATION LIMIT: Asking user for guidance at {max_iterations} iterations"
                         )
 
-                    # Extend the limit temporarily to allow processing the response
-                    max_iterations += 5  # Give 5 more iterations to process user guidance
+                    max_iterations += 5
                     response_state.awaiting_user_guidance = True
 
                 # Increment iteration counter
@@ -520,6 +365,13 @@ Please let me know how to proceed."""
                 buffered_tasks = tool_buffer.flush()
                 start_time = time.time()
 
+                # Update spinner message for final batch execution
+                tool_names = [part.tool_name for part, _ in buffered_tasks]
+                batch_msg = get_batch_description(len(buffered_tasks), tool_names)
+                await ui.update_spinner_message(
+                    f"[bold #00d7ff]{batch_msg}...[/bold #00d7ff]", state_manager
+                )
+
                 await ui.muted("\n" + "=" * 60)
                 await ui.muted(
                     f"🚀 FINAL BATCH: Executing {len(buffered_tasks)} buffered read-only tools"
@@ -553,8 +405,12 @@ Please let me know how to proceed."""
                     f"(~{speedup:.1f}x faster than sequential)\n"
                 )
 
+                # Reset spinner back to thinking
+                from tunacode.constants import UI_THINKING_MESSAGE
+
+                await ui.update_spinner_message(UI_THINKING_MESSAGE, state_manager)
+
             # If we need to add a fallback response, create a wrapper
-            # Don't add fallback if task was explicitly completed
             if (
                 not response_state.has_user_response
                 and not response_state.task_completed
@@ -564,100 +420,18 @@ Please let me know how to proceed."""
                 patch_tool_messages("Task incomplete", state_manager=state_manager)
                 response_state.has_final_synthesis = True
 
-                # Extract context from the agent run
-                tool_calls_summary = []
-                files_modified = set()
-                commands_run = []
-
-                # Analyze message history for context
-                for msg in state_manager.session.messages:
-                    if hasattr(msg, "parts"):
-                        for part in msg.parts:
-                            if hasattr(part, "part_kind") and part.part_kind == "tool-call":
-                                tool_name = getattr(part, "tool_name", "unknown")
-                                tool_calls_summary.append(tool_name)
-
-                                # Track specific operations
-                                if tool_name in ["write_file", "update_file"] and hasattr(
-                                    part, "args"
-                                ):
-                                    if isinstance(part.args, dict) and "file_path" in part.args:
-                                        files_modified.add(part.args["file_path"])
-                                elif tool_name in ["run_command", "bash"] and hasattr(part, "args"):
-                                    if isinstance(part.args, dict) and "command" in part.args:
-                                        commands_run.append(part.args["command"])
-
-                # Build fallback response with context
-                fallback = FallbackResponse(
-                    summary="Reached maximum iterations without producing a final response.",
-                    progress=f"Completed {i} iterations (limit: {max_iterations})",
-                )
-
-                # Get verbosity setting
                 verbosity = state_manager.session.user_config.get("settings", {}).get(
                     "fallback_verbosity", "normal"
                 )
-
-                if verbosity in ["normal", "detailed"]:
-                    # Add what was attempted
-                    if tool_calls_summary:
-                        tool_counts: dict[str, int] = {}
-                        for tool in tool_calls_summary:
-                            tool_counts[tool] = tool_counts.get(tool, 0) + 1
-
-                        fallback.issues.append(f"Executed {len(tool_calls_summary)} tool calls:")
-                        for tool, count in sorted(tool_counts.items()):
-                            fallback.issues.append(f"  • {tool}: {count}x")
-
-                    if verbosity == "detailed":
-                        if files_modified:
-                            fallback.issues.append(f"\nFiles modified ({len(files_modified)}):")
-                            for f in sorted(files_modified)[:5]:  # Limit to 5 files
-                                fallback.issues.append(f"  • {f}")
-                            if len(files_modified) > 5:
-                                fallback.issues.append(
-                                    f"  • ... and {len(files_modified) - 5} more"
-                                )
-
-                        if commands_run:
-                            fallback.issues.append(f"\nCommands executed ({len(commands_run)}):")
-                            for cmd in commands_run[:3]:  # Limit to 3 commands
-                                # Truncate long commands
-                                display_cmd = cmd if len(cmd) <= 60 else cmd[:57] + "..."
-                                fallback.issues.append(f"  • {display_cmd}")
-                            if len(commands_run) > 3:
-                                fallback.issues.append(f"  • ... and {len(commands_run) - 3} more")
-
-                # Add helpful next steps
-                fallback.next_steps.append(
-                    "The task may be too complex - try breaking it into smaller steps"
-                )
-                fallback.next_steps.append(
-                    "Check the output above for any errors or partial progress"
+                fallback = create_fallback_response(
+                    i,
+                    max_iterations,
+                    state_manager.session.tool_calls,
+                    state_manager.session.messages,
+                    verbosity,
                 )
-                if files_modified:
-                    fallback.next_steps.append(
-                        "Review modified files to see what changes were made"
-                    )
-
-                # Create comprehensive output
-                output_parts = [fallback.summary, ""]
-
-                if fallback.progress:
-                    output_parts.append(f"Progress: {fallback.progress}")
-
-                if fallback.issues:
-                    output_parts.append("\nWhat happened:")
-                    output_parts.extend(fallback.issues)
-
-                if fallback.next_steps:
-                    output_parts.append("\nSuggested next steps:")
-                    for step in fallback.next_steps:
-                        output_parts.append(f"  • {step}")
-
-                comprehensive_output = "\n".join(output_parts)
+                comprehensive_output = format_fallback_output(fallback)
 
-                # Create a wrapper object that mimics AgentRun with the required attributes
                 wrapper = AgentRunWrapper(
                     agent_run, SimpleResult(comprehensive_output), response_state
                 )

tunacode/core/state.py

@@ -2,6 +2,8 @@
 
 State management system for session data in TunaCode CLI.
 Handles user preferences, conversation history, and runtime state.
+
+CLAUDE_ANCHOR[state-module]: Central state management and session tracking
 """
 
 import uuid
@@ -27,6 +29,8 @@ if TYPE_CHECKING:
 
 @dataclass
 class SessionState:
+    """CLAUDE_ANCHOR[session-state]: Core session state container"""
+
     user_config: UserConfig = field(default_factory=dict)
     agents: dict[str, Any] = field(
         default_factory=dict
@@ -44,9 +48,7 @@ class SessionState:
     input_sessions: InputSessions = field(default_factory=dict)
     current_task: Optional[Any] = None
     todos: list[TodoItem] = field(default_factory=list)
-    # ESC key tracking for double-press functionality
-    esc_press_count: int = 0
-    last_esc_time: Optional[float] = None
+    # Operation state tracking
     operation_cancelled: bool = False
     # Enhanced tracking for thoughts display
     files_in_context: set[str] = field(default_factory=set)
@@ -92,6 +94,8 @@ class SessionState:
 
 
 class StateManager:
+    """CLAUDE_ANCHOR[state-manager]: Main state manager singleton"""
+
     def __init__(self):
         self._session = SessionState()
         self._tool_handler: Optional["ToolHandler"] = None

tunacode/prompts/system.md

@@ -7,10 +7,11 @@ You are **"TunaCode"**, a **senior software developer AI assistant operating ins
 Your task is to **execute real actions** via tools and **report observations** after every tool use.
 
 **CRITICAL BEHAVIOR RULES:**
-1. When you say "Let me..." or "I will..." you MUST execute the corresponding tool in THE SAME RESPONSE
-2. Never describe what you'll do without doing it - ALWAYS execute tools when discussing actions
-3. When a task is COMPLETE, start your response with: TUNACODE_TASK_COMPLETE
-4. If your response is cut off or truncated, you'll be prompted to continue - complete your action
+1. **ALWAYS ANNOUNCE YOUR INTENTIONS FIRST**: Before executing any tools, briefly state what you're about to do (e.g., "I'll search for the main agent implementation" or "Let me examine the file structure")
+2. When you say "Let me..." or "I will..." you MUST execute the corresponding tool in THE SAME RESPONSE
+3. Never describe what you'll do without doing it - ALWAYS execute tools when discussing actions
+4. When a task is COMPLETE, start your response with: TUNACODE_TASK_COMPLETE
+5. If your response is cut off or truncated, you'll be prompted to continue - complete your action
 
 You MUST follow these rules:
 

tunacode/tools/grep.py

@@ -7,6 +7,8 @@ This tool provides sophisticated grep-like functionality with:
 - Smart result ranking and deduplication
 - Context-aware output formatting
 - Timeout handling for overly broad patterns (3 second deadline for first match)
+
+CLAUDE_ANCHOR[grep-module]: Fast parallel file search with 3-second deadline
 """
 
 import asyncio
@@ -29,7 +31,10 @@ from tunacode.tools.grep_components.result_formatter import ResultFormatter
 
 
 class ParallelGrep(BaseTool):
-    """Advanced parallel grep tool with multiple search strategies."""
+    """Advanced parallel grep tool with multiple search strategies.
+
+    CLAUDE_ANCHOR[parallel-grep-class]: Main grep implementation with timeout handling
+    """
 
     def __init__(self, ui_logger=None):
         super().__init__(ui_logger)
@@ -123,7 +128,13 @@ class ParallelGrep(BaseTool):
             # 4️⃣ Execute chosen strategy with pre-filtered candidates
             # Execute search with pre-filtered candidates
             if search_type == "ripgrep":
+                # Try ripgrep first for performance. If ripgrep is unavailable or
+                # returns no results (e.g., binary missing), gracefully fallback to
+                # the Python implementation so the tool still returns matches.
                 results = await self._ripgrep_search_filtered(pattern, candidates, config)
+                if not results:
+                    # Fallback to python search when ripgrep produced no output
+                    results = await self._python_search_filtered(pattern, candidates, config)
             elif search_type == "python":
                 results = await self._python_search_filtered(pattern, candidates, config)
             elif search_type == "hybrid":

tunacode/ui/console.py

@@ -21,6 +21,7 @@ from .output import (
     spinner,
     sync_print,
     update_available,
+    update_spinner_message,
     usage,
     version,
 )
@@ -93,6 +94,7 @@ __all__ = [
     "spinner",
     "sync_print",
     "update_available",
+    "update_spinner_message",
     "usage",
     "version",
     # Unified logging wrappers