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

tunacode/cli/commands/__init__.py

@@ -7,6 +7,8 @@ This package provides a modular command system with:
 
 The main public API provides backward compatibility with the original
 commands.py module while enabling better organization and maintainability.
+
+CLAUDE_ANCHOR[commands-module]: Command registry and dispatch system
 """
 
 # Import base classes and infrastructure

tunacode/cli/commands/registry.py

@@ -1,4 +1,7 @@
-"""Command registry and factory for TunaCode CLI commands."""
+"""Command registry and factory for TunaCode CLI commands.
+
+CLAUDE_ANCHOR[command-registry]: Central command registration and execution
+"""
 
 from dataclasses import dataclass
 from typing import Any, Dict, List, Optional, Type

tunacode/cli/repl.py

@@ -3,6 +3,8 @@ Module: tunacode.cli.repl
 
 Interactive REPL (Read-Eval-Print Loop) implementation for TunaCode.
 Handles user input, command processing, and agent interaction in an interactive shell.
+
+CLAUDE_ANCHOR[repl-module]: Core REPL loop and user interaction handling
 """
 
 # ============================================================================
@@ -41,7 +43,7 @@ MSG_TOOL_INTERRUPTED = "Tool execution was interrupted"
 MSG_REQUEST_CANCELLED = "Request cancelled"
 MSG_SESSION_ENDED = "Session ended. Happy coding!"
 MSG_AGENT_BUSY = "Agent is busy, press Ctrl+C to interrupt."
-MSG_HIT_CTRL_C = "Hit Ctrl+C again to exit"
+MSG_HIT_ABORT_KEY = "Hit ESC or Ctrl+C again to exit"
 SHELL_ENV_VAR = "SHELL"
 DEFAULT_SHELL = "bash"
 
@@ -94,7 +96,10 @@ async def _handle_command(command: str, state_manager: StateManager) -> CommandR
 
 
 async def process_request(text: str, state_manager: StateManager, output: bool = True):
-    """Process input using the agent, handling cancellation safely."""
+    """Process input using the agent, handling cancellation safely.
+
+    CLAUDE_ANCHOR[process-request-repl]: REPL's main request processor with error handling
+    """
     import uuid
 
     # Generate a unique ID for this request for correlated logging
@@ -245,7 +250,8 @@ async def process_request(text: str, state_manager: StateManager, output: bool =
 async def repl(state_manager: StateManager):
     """Main REPL loop that handles user interaction and input processing."""
     action = None
-    ctrl_c_pressed = False
+    abort_pressed = False
+    last_abort_time = 0.0
 
     model_name = state_manager.session.current_model
     max_tokens = (
@@ -270,16 +276,26 @@ async def repl(state_manager: StateManager):
             try:
                 line = await ui.multiline_input(state_manager, _command_registry)
             except UserAbortError:
-                if ctrl_c_pressed:
+                import time
+
+                current_time = time.time()
+
+                # Reset if more than 3 seconds have passed
+                if current_time - last_abort_time > 3.0:
+                    abort_pressed = False
+
+                if abort_pressed:
                     break
-                ctrl_c_pressed = True
-                await ui.warning(MSG_HIT_CTRL_C)
+
+                abort_pressed = True
+                last_abort_time = current_time
+                await ui.warning(MSG_HIT_ABORT_KEY)
                 continue
 
             if not line:
                 continue
 
-            ctrl_c_pressed = False
+            abort_pressed = False
 
             if line.lower() in ["exit", "quit"]:
                 break

tunacode/cli/repl_components/tool_executor.py

@@ -43,8 +43,9 @@ async def tool_handler(part, state_manager: StateManager):
     if tool_handler_instance.should_confirm(part.tool_name):
         await ui.info(f"Tool({part.tool_name})")
 
-    if not state_manager.session.is_streaming_active and state_manager.session.spinner:
-        state_manager.session.spinner.stop()
+    # Keep spinner running during tool execution - it will be updated with tool status
+    # if not state_manager.session.is_streaming_active and state_manager.session.spinner:
+    #     state_manager.session.spinner.stop()
 
     streaming_panel = None
     if state_manager.session.is_streaming_active and hasattr(
@@ -80,5 +81,6 @@ async def tool_handler(part, state_manager: StateManager):
         if streaming_panel and tool_handler_instance.should_confirm(part.tool_name):
             await streaming_panel.start()
 
-        if not state_manager.session.is_streaming_active and state_manager.session.spinner:
-            state_manager.session.spinner.start()
+        # Spinner continues running - no need to restart
+        # if not state_manager.session.is_streaming_active and state_manager.session.spinner:
+        #     state_manager.session.spinner.start()

tunacode/constants.py

@@ -9,7 +9,7 @@ from enum import Enum
 
 # Application info
 APP_NAME = "TunaCode"
-APP_VERSION = "0.0.53"
+APP_VERSION = "0.0.55"
 
 
 # File patterns

tunacode/core/agents/agent_components/__init__.py

@@ -1,6 +1,17 @@
 """Agent components package for modular agent functionality."""
 
 from .agent_config import get_or_create_agent
+from .agent_helpers import (
+    create_empty_response_message,
+    create_fallback_response,
+    create_progress_summary,
+    create_user_message,
+    format_fallback_output,
+    get_recent_tools_context,
+    get_tool_description,
+    get_tool_summary,
+    get_user_prompt_part_class,
+)
 from .json_tool_parser import extract_and_execute_tool_calls, parse_json_tool_calls
 from .message_handler import get_model_messages, patch_tool_messages
 from .node_processor import _process_node
@@ -24,4 +35,13 @@ __all__ = [
     "check_task_completion",
     "ToolBuffer",
     "execute_tools_parallel",
+    "create_empty_response_message",
+    "create_fallback_response",
+    "create_progress_summary",
+    "create_user_message",
+    "format_fallback_output",
+    "get_recent_tools_context",
+    "get_tool_description",
+    "get_tool_summary",
+    "get_user_prompt_part_class",
 ]

tunacode/core/agents/agent_components/agent_helpers.py

@@ -0,0 +1,219 @@
+"""Helper functions for agent operations to reduce code duplication."""
+
+from typing import Any
+
+from tunacode.core.state import StateManager
+from tunacode.types import FallbackResponse
+
+
+class UserPromptPartFallback:
+    """Fallback class for UserPromptPart when pydantic_ai is not available."""
+
+    def __init__(self, content: str, part_kind: str):
+        self.content = content
+        self.part_kind = part_kind
+
+
+# Cache for UserPromptPart class
+_USER_PROMPT_PART_CLASS = None
+
+
+def get_user_prompt_part_class():
+    """Get UserPromptPart class with caching and fallback for test environment."""
+    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:
+            _USER_PROMPT_PART_CLASS = UserPromptPartFallback
+    except Exception:
+        _USER_PROMPT_PART_CLASS = UserPromptPartFallback
+
+    return _USER_PROMPT_PART_CLASS
+
+
+def create_user_message(content: str, state_manager: StateManager):
+    """Create a user message and add it to the session messages."""
+    from .message_handler import get_model_messages
+
+    model_request_cls = get_model_messages()[0]
+    UserPromptPart = get_user_prompt_part_class()
+    user_prompt_part = UserPromptPart(content=content, part_kind="user-prompt")
+    message = model_request_cls(parts=[user_prompt_part], kind="request")
+    state_manager.session.messages.append(message)
+    return message
+
+
+def get_tool_summary(tool_calls: list[dict[str, Any]]) -> dict[str, int]:
+    """Generate a summary of tool usage from tool calls."""
+    tool_summary: dict[str, int] = {}
+    for tc in tool_calls:
+        tool_name = tc.get("tool", "unknown")
+        tool_summary[tool_name] = tool_summary.get(tool_name, 0) + 1
+    return tool_summary
+
+
+def get_tool_description(tool_name: str, tool_args: dict[str, Any]) -> str:
+    """Get a descriptive string for a tool call."""
+    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}')"
+    return tool_desc
+
+
+def get_recent_tools_context(tool_calls: list[dict[str, Any]], limit: int = 3) -> str:
+    """Get a context string describing recent tool usage."""
+    if not tool_calls:
+        return "No tools used yet"
+
+    last_tools = []
+    for tc in tool_calls[-limit:]:
+        tool_name = tc.get("tool", "unknown")
+        tool_args = tc.get("args", {})
+        tool_desc = get_tool_description(tool_name, tool_args)
+        last_tools.append(tool_desc)
+
+    return f"Recent tools: {', '.join(last_tools)}"
+
+
+def create_empty_response_message(
+    message: str,
+    empty_reason: str,
+    tool_calls: list[dict[str, Any]],
+    iteration: int,
+    state_manager: StateManager,
+) -> str:
+    """Create an aggressive message for handling empty responses."""
+    tools_context = get_recent_tools_context(tool_calls)
+
+    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: {iteration}
+
+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."""
+
+    return content
+
+
+def create_progress_summary(tool_calls: list[dict[str, Any]]) -> tuple[dict[str, int], str]:
+    """Create a progress summary from tool calls."""
+    tool_summary = get_tool_summary(tool_calls)
+
+    if tool_summary:
+        summary_str = ", ".join([f"{name}: {count}" for name, count in tool_summary.items()])
+    else:
+        summary_str = "No tools used yet"
+
+    return tool_summary, summary_str
+
+
+def create_fallback_response(
+    iterations: int,
+    max_iterations: int,
+    tool_calls: list[dict[str, Any]],
+    messages: list[Any],
+    verbosity: str = "normal",
+) -> FallbackResponse:
+    """Create a comprehensive fallback response when iteration limit is reached."""
+    fallback = FallbackResponse(
+        summary="Reached maximum iterations without producing a final response.",
+        progress=f"Completed {iterations} iterations (limit: {max_iterations})",
+    )
+
+    # Extract context from messages
+    tool_calls_summary = []
+    files_modified = set()
+    commands_run = []
+
+    for msg in 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"])
+
+    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]:
+                    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]:
+                    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")
+    if files_modified:
+        fallback.next_steps.append("Review modified files to see what changes were made")
+
+    return fallback
+
+
+def format_fallback_output(fallback: FallbackResponse) -> str:
+    """Format a fallback response into a comprehensive output string."""
+    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}")
+
+    return "\n".join(output_parts)

tunacode/core/agents/agent_components/node_processor.py

@@ -6,10 +6,12 @@ from typing import Any, Awaitable, Callable, Optional, Tuple
 from tunacode.core.logging.logger import get_logger
 from tunacode.core.state import StateManager
 from tunacode.types import UsageTrackerProtocol
+from tunacode.ui.tool_descriptions import get_batch_description, get_tool_description
 
 from .response_state import ResponseState
 from .task_completion import check_task_completion
 from .tool_buffer import ToolBuffer
+from .truncation_checker import check_for_truncation
 
 logger = get_logger(__name__)
 
@@ -171,7 +173,7 @@ async def _process_node(
             # Check for truncation patterns
             if all_content_parts:
                 combined_content = " ".join(all_content_parts).strip()
-                appears_truncated = _check_for_truncation(combined_content)
+                appears_truncated = check_for_truncation(combined_content)
 
             # If we only got empty content and no tool calls, we should NOT consider this a valid response
             # This prevents the agent from stopping when it gets empty responses
@@ -229,79 +231,6 @@ async def _process_node(
     return False, None
 
 
-def _check_for_truncation(combined_content: str) -> bool:
-    """Check if content appears to be truncated."""
-    if not combined_content:
-        return False
-
-    # Truncation indicators:
-    # 1. Ends with "..." or "…" (but not part of a complete sentence)
-    # 2. Ends mid-word (no punctuation, space, or complete word)
-    # 3. Contains incomplete markdown/code blocks
-    # 4. Ends with incomplete parentheses/brackets
-
-    # Check for ellipsis at end suggesting truncation
-    if combined_content.endswith(("...", "…")) and not combined_content.endswith(("....", "….")):
-        return True
-
-    # Check for mid-word truncation (ends with letters but no punctuation)
-    if combined_content and combined_content[-1].isalpha():
-        # Look for incomplete words by checking if last "word" seems cut off
-        words = combined_content.split()
-        if words:
-            last_word = words[-1]
-            # Common complete word endings vs likely truncations
-            complete_endings = (
-                "ing",
-                "ed",
-                "ly",
-                "er",
-                "est",
-                "tion",
-                "ment",
-                "ness",
-                "ity",
-                "ous",
-                "ive",
-                "able",
-                "ible",
-            )
-            incomplete_patterns = (
-                "referen",
-                "inte",
-                "proces",
-                "analy",
-                "deve",
-                "imple",
-                "execu",
-            )
-
-            if any(last_word.lower().endswith(pattern) for pattern in incomplete_patterns):
-                return True
-            elif len(last_word) > 2 and not any(
-                last_word.lower().endswith(end) for end in complete_endings
-            ):
-                # Likely truncated if doesn't end with common suffix
-                return True
-
-    # Check for unclosed markdown code blocks
-    code_block_count = combined_content.count("```")
-    if code_block_count % 2 != 0:
-        return True
-
-    # Check for unclosed brackets/parentheses (more opens than closes)
-    open_brackets = (
-        combined_content.count("[") + combined_content.count("(") + combined_content.count("{")
-    )
-    close_brackets = (
-        combined_content.count("]") + combined_content.count(")") + combined_content.count("}")
-    )
-    if open_brackets > close_brackets:
-        return True
-
-    return False
-
-
 async def _display_raw_api_response(node: Any, ui: Any) -> None:
     """Display raw API response data when thoughts are enabled."""
 
@@ -382,6 +311,14 @@ async def _process_tool_calls(
                 if tool_buffer is not None and part.tool_name in READ_ONLY_TOOLS:
                     # Add to buffer instead of executing immediately
                     tool_buffer.add(part, node)
+
+                    # Update spinner to show we're collecting tools
+                    buffered_count = len(tool_buffer.read_only_tasks)
+                    await ui.update_spinner_message(
+                        f"[bold #00d7ff]Collecting tools ({buffered_count} buffered)...[/bold #00d7ff]",
+                        state_manager,
+                    )
+
                     if state_manager.session.show_thoughts:
                         await ui.muted(
                             f"⏸️ BUFFERED: {part.tool_name} (will execute in parallel batch)"
@@ -399,6 +336,13 @@ async def _process_tool_calls(
 
                         start_time = time.time()
 
+                        # Update spinner message for 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
+                        )
+
                         # Enhanced visual feedback for parallel execution
                         await ui.muted("\n" + "=" * 60)
                         await ui.muted(
@@ -452,9 +396,30 @@ async def _process_tool_calls(
                             f"(~{speedup:.1f}x faster than sequential)\n"
                         )
 
+                        # Reset spinner message back to thinking
+                        from tunacode.constants import UI_THINKING_MESSAGE
+
+                        await ui.update_spinner_message(UI_THINKING_MESSAGE, state_manager)
+
                     # Now execute the write/execute tool
                     if state_manager.session.show_thoughts:
                         await ui.warning(f"⚠️ SEQUENTIAL: {part.tool_name} (write/execute tool)")
+
+                    # Update spinner for sequential tool
+                    tool_args = getattr(part, "args", {}) if hasattr(part, "args") else {}
+                    # Parse args if they're a JSON string
+                    if isinstance(tool_args, str):
+                        import json
+
+                        try:
+                            tool_args = json.loads(tool_args)
+                        except (json.JSONDecodeError, TypeError):
+                            tool_args = {}
+                    tool_desc = get_tool_description(part.tool_name, tool_args)
+                    await ui.update_spinner_message(
+                        f"[bold #00d7ff]{tool_desc}...[/bold #00d7ff]", state_manager
+                    )
+
                     await tool_callback(part, node)
 
     # Track tool calls in session

tunacode/core/agents/agent_components/truncation_checker.py

@@ -0,0 +1,81 @@
+"""Truncation detection utilities for agent responses."""
+
+
+def check_for_truncation(combined_content: str) -> bool:
+    """Check if content appears to be truncated.
+
+    Args:
+        combined_content: The text content to check for truncation
+
+    Returns:
+        bool: True if the content appears truncated, False otherwise
+    """
+    if not combined_content:
+        return False
+
+    # Truncation indicators:
+    # 1. Ends with "..." or "…" (but not part of a complete sentence)
+    # 2. Ends mid-word (no punctuation, space, or complete word)
+    # 3. Contains incomplete markdown/code blocks
+    # 4. Ends with incomplete parentheses/brackets
+
+    # Check for ellipsis at end suggesting truncation
+    if combined_content.endswith(("...", "…")) and not combined_content.endswith(("....", "….")):
+        return True
+
+    # Check for mid-word truncation (ends with letters but no punctuation)
+    if combined_content and combined_content[-1].isalpha():
+        # Look for incomplete words by checking if last "word" seems cut off
+        words = combined_content.split()
+        if words:
+            last_word = words[-1]
+            # Common complete word endings vs likely truncations
+            complete_endings = (
+                "ing",
+                "ed",
+                "ly",
+                "er",
+                "est",
+                "tion",
+                "ment",
+                "ness",
+                "ity",
+                "ous",
+                "ive",
+                "able",
+                "ible",
+            )
+            incomplete_patterns = (
+                "referen",
+                "inte",
+                "proces",
+                "analy",
+                "deve",
+                "imple",
+                "execu",
+            )
+
+            if any(last_word.lower().endswith(pattern) for pattern in incomplete_patterns):
+                return True
+            elif len(last_word) > 2 and not any(
+                last_word.lower().endswith(end) for end in complete_endings
+            ):
+                # Likely truncated if doesn't end with common suffix
+                return True
+
+    # Check for unclosed markdown code blocks
+    code_block_count = combined_content.count("```")
+    if code_block_count % 2 != 0:
+        return True
+
+    # Check for unclosed brackets/parentheses (more opens than closes)
+    open_brackets = (
+        combined_content.count("[") + combined_content.count("(") + combined_content.count("{")
+    )
+    close_brackets = (
+        combined_content.count("]") + combined_content.count(")") + combined_content.count("}")
+    )
+    if open_brackets > close_brackets:
+        return True
+
+    return False