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

tunacode/cli/repl_components/__init__.py

@@ -0,0 +1,10 @@
+"""
+REPL components package for modular REPL functionality.
+"""
+
+from .command_parser import parse_args
+from .error_recovery import attempt_tool_recovery
+from .output_display import display_agent_output
+from .tool_executor import tool_handler
+
+__all__ = ["parse_args", "attempt_tool_recovery", "display_agent_output", "tool_handler"]

tunacode/cli/repl_components/command_parser.py

@@ -0,0 +1,34 @@
+"""
+Module: tunacode.cli.repl_components.command_parser
+
+Command parsing utilities for the REPL.
+"""
+
+import json
+
+from tunacode.exceptions import ValidationError
+from tunacode.types import ToolArgs
+
+
+def parse_args(args) -> ToolArgs:
+    """
+    Parse tool arguments from a JSON string or dictionary.
+
+    Args:
+        args (str or dict): A JSON-formatted string or a dictionary containing tool arguments.
+
+    Returns:
+        dict: The parsed arguments.
+
+    Raises:
+        ValueError: If 'args' is not a string or dictionary, or if the string is not valid JSON.
+    """
+    if isinstance(args, str):
+        try:
+            return json.loads(args)
+        except json.JSONDecodeError:
+            raise ValidationError(f"Invalid JSON: {args}")
+    elif isinstance(args, dict):
+        return args
+    else:
+        raise ValidationError(f"Invalid args type: {type(args)}")

tunacode/cli/repl_components/error_recovery.py

@@ -0,0 +1,88 @@
+"""
+Module: tunacode.cli.repl_components.error_recovery
+
+Error recovery utilities for the REPL.
+"""
+
+import logging
+
+from tunacode.types import StateManager
+from tunacode.ui import console as ui
+
+from .tool_executor import tool_handler
+
+logger = logging.getLogger(__name__)
+
+MSG_JSON_RECOVERY = "Recovered using JSON tool parsing"
+
+
+async def attempt_tool_recovery(e: Exception, state_manager: StateManager) -> bool:
+    """
+    Attempt to recover from tool calling failures by parsing raw JSON from the last message.
+
+    Returns:
+        bool: True if recovery was successful, False otherwise
+    """
+    error_str = str(e).lower()
+    tool_keywords = ["tool", "function", "call", "schema"]
+    if not any(keyword in error_str for keyword in tool_keywords):
+        return False
+
+    if not state_manager.session.messages:
+        return False
+
+    last_msg = state_manager.session.messages[-1]
+    if not hasattr(last_msg, "parts"):
+        return False
+
+    for part in last_msg.parts:
+        content_to_parse = getattr(part, "content", None)
+        if not isinstance(content_to_parse, str) or not content_to_parse.strip():
+            continue
+
+        logger.debug(
+            "Attempting JSON tool recovery on content",
+            extra={
+                "content_preview": content_to_parse[:200],
+                "original_error": str(e),
+            },
+        )
+        await ui.muted(
+            f"⚠️ Model response error. Attempting to recover by parsing tools 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(
+                content_to_parse, tool_callback_with_state, state_manager
+            )
+
+            # Treat any truthy return value as success – we don't depend on an exact count.
+            if tools_found:
+                await ui.warning(f" {MSG_JSON_RECOVERY}")
+                logger.info(
+                    "Successfully recovered from JSON tool parsing error.",
+                    extra={"tools_executed": tools_found},
+                )
+                return True
+            else:
+                logger.debug("Recovery attempted, but no tools were found in content.")
+
+        except Exception as recovery_exc:
+            logger.error(
+                "Exception during JSON tool recovery attempt",
+                exc_info=True,
+                extra={"recovery_exception": str(recovery_exc)},
+            )
+            continue  # Try next part if available
+
+    # If we attempted recovery but could not execute any tools, simply
+    # return False so that the caller can handle the original error. We avoid
+    # emitting an additional error message here to prevent duplicate UI
+    # notifications which would otherwise break expectations in unit tests.
+    return False

tunacode/cli/repl_components/output_display.py

@@ -0,0 +1,33 @@
+"""
+Module: tunacode.cli.repl_components.output_display
+
+Output formatting and display utilities for the REPL.
+"""
+
+from tunacode.ui import console as ui
+
+# MSG_REQUEST_COMPLETED is used in repl.py
+MSG_REQUEST_COMPLETED = "Request completed"
+
+
+async def display_agent_output(res, enable_streaming: bool) -> None:
+    """Display agent output using guard clauses to flatten nested conditionals."""
+    if enable_streaming:
+        return
+
+    if not hasattr(res, "result") or res.result is None or not hasattr(res.result, "output"):
+        await ui.muted(MSG_REQUEST_COMPLETED)
+        return
+
+    output = res.result.output
+
+    if not isinstance(output, str):
+        return
+
+    if output.strip().startswith('{"thought"'):
+        return
+
+    if '"tool_uses"' in output:
+        return
+
+    await ui.agent(output)

tunacode/cli/repl_components/tool_executor.py

@@ -0,0 +1,84 @@
+"""
+Module: tunacode.cli.repl_components.tool_executor
+
+Tool execution and confirmation handling for the REPL.
+"""
+
+import logging
+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.tool_handler import ToolHandler
+from tunacode.exceptions import UserAbortError
+from tunacode.types import StateManager
+from tunacode.ui import console as ui
+from tunacode.ui.tool_ui import ToolUI
+
+from .command_parser import parse_args
+
+logger = logging.getLogger(__name__)
+
+_tool_ui = ToolUI()
+
+MSG_OPERATION_ABORTED_BY_USER = "Operation aborted by user."
+
+
+async def tool_handler(part, state_manager: StateManager):
+    """Handle tool execution with separated business logic and UI."""
+    # Check for cancellation before tool execution (only if explicitly set to True)
+    operation_cancelled = getattr(state_manager.session, "operation_cancelled", False)
+    if operation_cancelled is True:
+        logger.debug("Tool execution cancelled")
+        raise CancelledError("Operation was cancelled")
+
+    # Get or create tool handler
+    if state_manager.tool_handler is None:
+        tool_handler_instance = ToolHandler(state_manager)
+        state_manager.set_tool_handler(tool_handler_instance)
+    else:
+        tool_handler_instance = state_manager.tool_handler
+
+    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()
+
+    streaming_panel = None
+    if state_manager.session.is_streaming_active and hasattr(
+        state_manager.session, "streaming_panel"
+    ):
+        streaming_panel = state_manager.session.streaming_panel
+        if streaming_panel and tool_handler_instance.should_confirm(part.tool_name):
+            await streaming_panel.stop()
+
+    try:
+        args = parse_args(part.args)
+
+        def confirm_func():
+            if not tool_handler_instance.should_confirm(part.tool_name):
+                return False
+            request = tool_handler_instance.create_confirmation_request(part.tool_name, args)
+
+            response = _tool_ui.show_sync_confirmation(request)
+
+            if not tool_handler_instance.process_confirmation(response, part.tool_name):
+                return True  # Abort
+            return False  # Continue
+
+        should_abort = await run_in_terminal(confirm_func)
+
+        if should_abort:
+            raise UserAbortError("User aborted.")
+
+    except UserAbortError:
+        patch_tool_messages(MSG_OPERATION_ABORTED_BY_USER, state_manager)
+        raise
+    finally:
+        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()

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, TOOL_READ_FILE
+from tunacode.constants import GUIDE_FILE_NAME, ToolName
 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": [TOOL_READ_FILE],
+        "tool_ignore": [ToolName.READ_FILE],
         "guide_file": GUIDE_FILE_NAME,
         "fallback_response": True,
         "fallback_verbosity": "normal",  # Options: minimal, normal, detailed

tunacode/configuration/settings.py

@@ -7,16 +7,8 @@ Handles configuration paths, model registries, and application metadata.
 
 from pathlib import Path
 
-from tunacode.constants import (
-    APP_NAME,
-    APP_VERSION,
-    CONFIG_FILE_NAME,
-    TOOL_READ_FILE,
-    TOOL_RUN_COMMAND,
-    TOOL_UPDATE_FILE,
-    TOOL_WRITE_FILE,
-)
-from tunacode.types import ConfigFile, ConfigPath, ToolName
+from tunacode.constants import APP_NAME, APP_VERSION, CONFIG_FILE_NAME, ToolName
+from tunacode.types import ConfigFile, ConfigPath
 
 
 class PathConfig:
@@ -32,8 +24,13 @@ class ApplicationSettings:
         self.guide_file = f"{self.name.upper()}.md"
         self.paths = PathConfig()
         self.internal_tools: list[ToolName] = [
-            TOOL_READ_FILE,
-            TOOL_RUN_COMMAND,
-            TOOL_UPDATE_FILE,
-            TOOL_WRITE_FILE,
+            ToolName.BASH,
+            ToolName.GLOB,
+            ToolName.GREP,
+            ToolName.LIST_DIR,
+            ToolName.READ_FILE,
+            ToolName.RUN_COMMAND,
+            ToolName.TODO,
+            ToolName.UPDATE_FILE,
+            ToolName.WRITE_FILE,
         ]

tunacode/constants.py

@@ -5,9 +5,11 @@ Global constants and configuration values for the TunaCode CLI application.
 Centralizes all magic strings, UI text, error messages, and application constants.
 """
 
+from enum import Enum
+
 # Application info
 APP_NAME = "TunaCode"
-APP_VERSION = "0.0.50"
+APP_VERSION = "0.0.53"
 
 
 # File patterns
@@ -29,21 +31,36 @@ COMMAND_OUTPUT_THRESHOLD = 3500  # Length threshold for truncation
 COMMAND_OUTPUT_START_INDEX = 2500  # Where to start showing content
 COMMAND_OUTPUT_END_SIZE = 1000  # How much to show from the end
 
-# Tool names
-TOOL_READ_FILE = "read_file"
-TOOL_WRITE_FILE = "write_file"
-TOOL_UPDATE_FILE = "update_file"
-TOOL_RUN_COMMAND = "run_command"
-TOOL_BASH = "bash"
-TOOL_GREP = "grep"
-TOOL_LIST_DIR = "list_dir"
-TOOL_GLOB = "glob"
-TOOL_TODO = "todo"
+
+class ToolName(str, Enum):
+    """Enumeration of tool names."""
+
+    READ_FILE = "read_file"
+    WRITE_FILE = "write_file"
+    UPDATE_FILE = "update_file"
+    RUN_COMMAND = "run_command"
+    BASH = "bash"
+    GREP = "grep"
+    LIST_DIR = "list_dir"
+    GLOB = "glob"
+    TODO = "todo"
+
+
+# Tool names (backward compatibility)
+TOOL_READ_FILE = ToolName.READ_FILE
+TOOL_WRITE_FILE = ToolName.WRITE_FILE
+TOOL_UPDATE_FILE = ToolName.UPDATE_FILE
+TOOL_RUN_COMMAND = ToolName.RUN_COMMAND
+TOOL_BASH = ToolName.BASH
+TOOL_GREP = ToolName.GREP
+TOOL_LIST_DIR = ToolName.LIST_DIR
+TOOL_GLOB = ToolName.GLOB
+TOOL_TODO = ToolName.TODO
 
 # Tool categorization
-READ_ONLY_TOOLS = [TOOL_READ_FILE, TOOL_GREP, TOOL_LIST_DIR, TOOL_GLOB]
-WRITE_TOOLS = [TOOL_WRITE_FILE, TOOL_UPDATE_FILE]
-EXECUTE_TOOLS = [TOOL_BASH, TOOL_RUN_COMMAND]
+READ_ONLY_TOOLS = [ToolName.READ_FILE, ToolName.GREP, ToolName.LIST_DIR, ToolName.GLOB]
+WRITE_TOOLS = [ToolName.WRITE_FILE, ToolName.UPDATE_FILE]
+EXECUTE_TOOLS = [ToolName.BASH, ToolName.RUN_COMMAND]
 
 # Commands
 CMD_HELP = "/help"
@@ -142,16 +159,33 @@ MSG_UPDATE_INSTRUCTION = "Exit, and run: [bold]pip install --upgrade tunacode-cl
 MSG_VERSION_DISPLAY = "TunaCode CLI {version}"
 MSG_FILE_SIZE_LIMIT = " Please specify a smaller file or use other tools to process it."
 
-# Todo-related constants
-TODO_STATUS_PENDING = "pending"
-TODO_STATUS_IN_PROGRESS = "in_progress"
-TODO_STATUS_COMPLETED = "completed"
-TODO_STATUSES = [TODO_STATUS_PENDING, TODO_STATUS_IN_PROGRESS, TODO_STATUS_COMPLETED]
 
-TODO_PRIORITY_HIGH = "high"
-TODO_PRIORITY_MEDIUM = "medium"
-TODO_PRIORITY_LOW = "low"
-TODO_PRIORITIES = [TODO_PRIORITY_HIGH, TODO_PRIORITY_MEDIUM, TODO_PRIORITY_LOW]
+class TodoStatus(str, Enum):
+    """Enumeration of todo statuses."""
+
+    PENDING = "pending"
+    IN_PROGRESS = "in_progress"
+    COMPLETED = "completed"
+
+
+class TodoPriority(str, Enum):
+    """Enumeration of todo priorities."""
+
+    HIGH = "high"
+    MEDIUM = "medium"
+    LOW = "low"
+
+
+# Todo-related constants (backward compatibility)
+TODO_STATUS_PENDING = TodoStatus.PENDING
+TODO_STATUS_IN_PROGRESS = TodoStatus.IN_PROGRESS
+TODO_STATUS_COMPLETED = TodoStatus.COMPLETED
+TODO_STATUSES = [TodoStatus.PENDING, TodoStatus.IN_PROGRESS, TodoStatus.COMPLETED]
+
+TODO_PRIORITY_HIGH = TodoPriority.HIGH
+TODO_PRIORITY_MEDIUM = TodoPriority.MEDIUM
+TODO_PRIORITY_LOW = TodoPriority.LOW
+TODO_PRIORITIES = [TodoPriority.HIGH, TodoPriority.MEDIUM, TodoPriority.LOW]
 
 # Maximum number of todos allowed per session
 MAX_TODOS_PER_SESSION = 100

tunacode/context.py

@@ -69,17 +69,3 @@ async def get_code_style() -> str:
 async def get_claude_files() -> List[str]:
     """Return a list of additional TUNACODE.md files in the repo."""
     return ripgrep("TUNACODE.md", ".")
-
-
-async def get_context() -> Dict[str, object]:
-    """Gather repository context."""
-    git = await get_git_status()
-    directory = await get_directory_structure()
-    style = await get_code_style()
-    claude_files = await get_claude_files()
-    return {
-        "git": git,
-        "directory": directory,
-        "codeStyle": style,
-        "claudeFiles": claude_files,
-    }

tunacode/core/agents/agent_components/__init__.py

@@ -0,0 +1,27 @@
+"""Agent components package for modular agent functionality."""
+
+from .agent_config import get_or_create_agent
+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
+from .response_state import ResponseState
+from .result_wrapper import AgentRunWithState, AgentRunWrapper, SimpleResult
+from .task_completion import check_task_completion
+from .tool_buffer import ToolBuffer
+from .tool_executor import execute_tools_parallel
+
+__all__ = [
+    "get_or_create_agent",
+    "extract_and_execute_tool_calls",
+    "parse_json_tool_calls",
+    "get_model_messages",
+    "patch_tool_messages",
+    "_process_node",
+    "ResponseState",
+    "AgentRunWithState",
+    "AgentRunWrapper",
+    "SimpleResult",
+    "check_task_completion",
+    "ToolBuffer",
+    "execute_tools_parallel",
+]

tunacode/core/agents/agent_components/agent_config.py

@@ -0,0 +1,109 @@
+"""Agent configuration and creation utilities."""
+
+from pathlib import Path
+
+from pydantic_ai import Agent
+
+from tunacode.core.logging.logger import get_logger
+from tunacode.core.state import StateManager
+from tunacode.services.mcp import get_mcp_servers
+from tunacode.tools.bash import bash
+from tunacode.tools.glob import glob
+from tunacode.tools.grep import grep
+from tunacode.tools.list_dir import list_dir
+from tunacode.tools.read_file import read_file
+from tunacode.tools.run_command import run_command
+from tunacode.tools.todo import TodoTool
+from tunacode.tools.update_file import update_file
+from tunacode.tools.write_file import write_file
+from tunacode.types import ModelName, PydanticAgent
+
+logger = get_logger(__name__)
+
+
+def get_agent_tool():
+    """Lazy import for Agent and Tool to avoid circular imports."""
+    from pydantic_ai import Tool
+
+    return Agent, Tool
+
+
+def load_system_prompt(base_path: Path) -> str:
+    """Load the system prompt from file."""
+    prompt_path = base_path / "prompts" / "system.md"
+    try:
+        with open(prompt_path, "r", encoding="utf-8") as f:
+            return f.read().strip()
+    except FileNotFoundError:
+        # Fallback to system.txt if system.md not found
+        prompt_path = base_path / "prompts" / "system.txt"
+        try:
+            with open(prompt_path, "r", encoding="utf-8") as f:
+                return f.read().strip()
+        except FileNotFoundError:
+            # Use a default system prompt if neither file exists
+            return "You are a helpful AI assistant for software development tasks."
+
+
+def load_tunacode_context() -> str:
+    """Load TUNACODE.md context if it exists."""
+    try:
+        tunacode_path = Path.cwd() / "TUNACODE.md"
+        if tunacode_path.exists():
+            tunacode_content = tunacode_path.read_text(encoding="utf-8")
+            if tunacode_content.strip():
+                logger.info("📄 TUNACODE.md located: Loading context...")
+                return "\n\n# Project Context from TUNACODE.md\n" + tunacode_content
+            else:
+                logger.info("📄 TUNACODE.md not found: Using default context")
+        else:
+            logger.info("📄 TUNACODE.md not found: Using default context")
+    except Exception as e:
+        logger.debug(f"Error loading TUNACODE.md: {e}")
+    return ""
+
+
+def get_or_create_agent(model: ModelName, state_manager: StateManager) -> PydanticAgent:
+    """Get existing agent or create new one for the specified model."""
+    if model not in state_manager.session.agents:
+        max_retries = state_manager.session.user_config.get("settings", {}).get("max_retries", 3)
+
+        # Lazy import Agent and Tool
+        Agent, Tool = get_agent_tool()
+
+        # Load system prompt
+        base_path = Path(__file__).parent.parent.parent.parent
+        system_prompt = load_system_prompt(base_path)
+
+        # Load TUNACODE.md context
+        system_prompt += load_tunacode_context()
+
+        # Initialize todo tool
+        todo_tool = TodoTool(state_manager=state_manager)
+
+        # Add todo context if available
+        try:
+            current_todos = todo_tool.get_current_todos_sync()
+            if current_todos != "No todos found":
+                system_prompt += f'\n\n# Current Todo List\n\nYou have existing todos that need attention:\n\n{current_todos}\n\nRemember to check progress on these todos and update them as you work. Use todo("list") to see current status anytime.'
+        except Exception as e:
+            logger.warning(f"Warning: Failed to load todos: {e}")
+
+        # Create agent with all tools
+        state_manager.session.agents[model] = Agent(
+            model=model,
+            system_prompt=system_prompt,
+            tools=[
+                Tool(bash, max_retries=max_retries),
+                Tool(glob, max_retries=max_retries),
+                Tool(grep, max_retries=max_retries),
+                Tool(list_dir, max_retries=max_retries),
+                Tool(read_file, max_retries=max_retries),
+                Tool(run_command, max_retries=max_retries),
+                Tool(todo_tool._execute, max_retries=max_retries),
+                Tool(update_file, max_retries=max_retries),
+                Tool(write_file, max_retries=max_retries),
+            ],
+            mcp_servers=get_mcp_servers(state_manager),
+        )
+    return state_manager.session.agents[model]

tunacode/core/agents/agent_components/json_tool_parser.py

@@ -0,0 +1,109 @@
+"""JSON tool call parsing utilities for fallback functionality."""
+
+import json
+from datetime import datetime
+from typing import Any, Awaitable, Callable, Optional
+
+from tunacode.core.logging.logger import get_logger
+from tunacode.core.state import StateManager
+
+logger = get_logger(__name__)
+
+ToolCallback = Callable[[Any, Any], Awaitable[Any]]
+
+
+async def parse_json_tool_calls(
+    text: str, tool_callback: Optional[ToolCallback], state_manager: StateManager
+) -> int:
+    """
+    Parse JSON tool calls from text when structured tool calling fails.
+    Fallback for when API providers don't support proper tool calling.
+
+    Returns:
+        int: Number of tools successfully executed
+    """
+    if not tool_callback:
+        return 0
+
+    # Pattern for JSON tool calls: {"tool": "tool_name", "args": {...}}
+    # Find potential JSON objects and parse them
+    potential_jsons = []
+    brace_count = 0
+    start_pos = -1
+
+    for i, char in enumerate(text):
+        if char == "{":
+            if brace_count == 0:
+                start_pos = i
+            brace_count += 1
+        elif char == "}":
+            brace_count -= 1
+            if brace_count == 0 and start_pos != -1:
+                potential_json = text[start_pos : i + 1]
+                try:
+                    parsed = json.loads(potential_json)
+                    if isinstance(parsed, dict) and "tool" in parsed and "args" in parsed:
+                        potential_jsons.append((parsed["tool"], parsed["args"]))
+                except json.JSONDecodeError:
+                    logger.debug(
+                        f"Failed to parse potential JSON tool call: {potential_json[:50]}..."
+                    )
+                start_pos = -1
+
+    matches = potential_jsons
+    tools_executed = 0
+
+    for tool_name, args in matches:
+        try:
+            # Create a mock tool call object
+            class MockToolCall:
+                def __init__(self, tool_name: str, args: dict):
+                    self.tool_name = tool_name
+                    self.args = args
+                    self.tool_call_id = f"fallback_{datetime.now().timestamp()}"
+
+            class MockNode:
+                pass
+
+            # Execute the tool through the callback
+            mock_call = MockToolCall(tool_name, args)
+            mock_node = MockNode()
+
+            await tool_callback(mock_call, mock_node)
+            tools_executed += 1
+
+            if state_manager.session.show_thoughts:
+                from tunacode.ui import console as ui
+
+                await ui.muted(f"FALLBACK: Executed {tool_name} via JSON parsing")
+
+        except Exception as e:
+            if state_manager.session.show_thoughts:
+                from tunacode.ui import console as ui
+
+                await ui.error(f"Error executing fallback tool {tool_name}: {str(e)}")
+
+    return tools_executed
+
+
+async def extract_and_execute_tool_calls(
+    text: str, tool_callback: Optional[ToolCallback], state_manager: StateManager
+) -> int:
+    """
+    Extract tool calls from text content and execute them.
+    Supports multiple formats for maximum compatibility.
+
+    Returns:
+        int: Number of tools successfully executed
+    """
+    if not tool_callback:
+        return 0
+
+    tools_executed = 0
+
+    # First try JSON format
+    tools_executed += await parse_json_tool_calls(text, tool_callback, state_manager)
+
+    # Add more formats here if needed in the future
+
+    return tools_executed