tunacode-cli 0.0.56__py3-none-any.whl → 0.0.60__py3-none-any.whl

tunacode/cli/repl_components/command_parser.py

@@ -5,14 +5,24 @@ Command parsing utilities for the REPL.
 """
 
 import json
+import logging
 
+from tunacode.constants import (
+    JSON_PARSE_BASE_DELAY,
+    JSON_PARSE_MAX_DELAY,
+    JSON_PARSE_MAX_RETRIES,
+)
 from tunacode.exceptions import ValidationError
 from tunacode.types import ToolArgs
+from tunacode.utils.json_utils import safe_json_parse
+from tunacode.utils.retry import retry_json_parse
+
+logger = logging.getLogger(__name__)
 
 
 def parse_args(args) -> ToolArgs:
     """
-    Parse tool arguments from a JSON string or dictionary.
+    Parse tool arguments from a JSON string or dictionary with retry logic.
 
     Args:
         args (str or dict): A JSON-formatted string or a dictionary containing tool arguments.
@@ -21,12 +31,35 @@ def parse_args(args) -> ToolArgs:
         dict: The parsed arguments.
 
     Raises:
-        ValueError: 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:
-            return json.loads(args)
-        except json.JSONDecodeError:
+            # First attempt: Use retry logic for transient failures
+            return retry_json_parse(
+                args,
+                max_retries=JSON_PARSE_MAX_RETRIES,
+                base_delay=JSON_PARSE_BASE_DELAY,
+                max_delay=JSON_PARSE_MAX_DELAY,
+            )
+        except json.JSONDecodeError as e:
+            # Check if this is an "Extra data" error (concatenated JSON objects)
+            if "Extra data" in str(e):
+                logger.warning(f"Detected concatenated JSON objects in args: {args[:200]}...")
+                try:
+                    # Use the new safe JSON parser with concatenation support
+                    result = safe_json_parse(args, allow_concatenated=True)
+                    if isinstance(result, dict):
+                        return result
+                    elif isinstance(result, list) and result:
+                        # Multiple objects - return first one
+                        logger.warning("Multiple JSON objects detected, using first object only")
+                        return result[0]
+                except Exception:
+                    # If safe parsing also fails, fall through to original error
+                    pass
+
+            # Original error - no recovery possible
             raise ValidationError(f"Invalid JSON: {args}")
     elif isinstance(args, dict):
         return args

tunacode/cli/repl_components/error_recovery.py

@@ -14,6 +14,77 @@ from .tool_executor import tool_handler
 logger = logging.getLogger(__name__)
 
 MSG_JSON_RECOVERY = "Recovered using JSON tool parsing"
+MSG_JSON_ARGS_RECOVERY = "Recovered from malformed tool arguments"
+
+
+async def attempt_json_args_recovery(e: Exception, state_manager: StateManager) -> bool:
+    """
+    Attempt to recover from JSON parsing errors in tool arguments.
+
+    This handles cases where the model emits concatenated JSON objects
+    or other malformed JSON in tool call arguments.
+
+    Returns:
+        bool: True if recovery was successful, False otherwise
+    """
+    error_str = str(e).lower()
+
+    # Check if this is a JSON parsing error with tool arguments
+    if not any(
+        keyword in error_str for keyword in ["invalid json", "extra data", "jsondecodeerror"]
+    ):
+        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
+
+    # Look for tool call parts with malformed args
+    for part in last_msg.parts:
+        if hasattr(part, "tool_name") and hasattr(part, "args"):
+            # This is a structured tool call with potentially malformed args
+            try:
+                from tunacode.utils.json_utils import split_concatenated_json
+
+                # Try to split concatenated JSON objects in the args
+                if isinstance(part.args, str):
+                    logger.info(f"Attempting to recover malformed args for tool {part.tool_name}")
+
+                    try:
+                        json_objects = split_concatenated_json(part.args)
+                        if json_objects:
+                            # Use the first object as the args
+                            part.args = json_objects[0]
+
+                            # Execute the recovered tool call
+                            await tool_handler(part, state_manager)
+
+                            await ui.warning(f"Warning: {MSG_JSON_ARGS_RECOVERY}")
+                            logger.info(
+                                f"Successfully recovered tool {part.tool_name} with split JSON args",
+                                extra={
+                                    "original_args": part.args,
+                                    "recovered_args": json_objects[0],
+                                },
+                            )
+                            return True
+
+                    except Exception as split_exc:
+                        logger.debug(f"Failed to split JSON args: {split_exc}")
+                        continue
+
+            except Exception as recovery_exc:
+                logger.error(
+                    f"Error during JSON args recovery for tool {getattr(part, 'tool_name', 'unknown')}",
+                    exc_info=True,
+                    extra={"recovery_exception": str(recovery_exc)},
+                )
+                continue
+
+    return False
 
 
 async def attempt_tool_recovery(e: Exception, state_manager: StateManager) -> bool:
@@ -25,9 +96,16 @@ async def attempt_tool_recovery(e: Exception, state_manager: StateManager) -> bo
     """
     error_str = str(e).lower()
     tool_keywords = ["tool", "function", "call", "schema"]
-    if not any(keyword in error_str for keyword in tool_keywords):
+    json_keywords = ["json", "invalid json", "jsondecodeerror", "extra data", "validation"]
+    recovery_keywords = tool_keywords + json_keywords
+
+    if not any(keyword in error_str for keyword in recovery_keywords):
         return False
 
+    # First, try JSON args recovery for structured tool calls with malformed args
+    if await attempt_json_args_recovery(e, state_manager):
+        return True
+
     if not state_manager.session.messages:
         return False
 

tunacode/cli/repl_components/output_display.py

@@ -29,22 +29,25 @@ 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
-    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"
-    ]):
+    if any(
+        phrase in output
+        for phrase in [
+            "PLAN MODE - TOOL EXECUTION ONLY",
+            "🔧 PLAN MODE",
+            "TOOL EXECUTION ONLY 🔧",
+            "planning assistant that ONLY communicates",
+            "namespace functions {",
+            "namespace multi_tool_use {",
+            "You are trained on data up to",
+        ]
+    ):
         return
 
     await ui.agent(output)

tunacode/cli/repl_components/tool_executor.py

@@ -62,12 +62,15 @@ async def tool_handler(part, state_manager: StateManager):
             # 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.")
+
+                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

@@ -24,6 +24,14 @@ DEFAULT_USER_CONFIG: UserConfig = {
         "fallback_response": True,
         "fallback_verbosity": "normal",  # Options: minimal, normal, detailed
         "context_window_size": 200000,
+        "ripgrep": {
+            "use_bundled": False,  # Use system ripgrep binary
+            "timeout": 10,  # Search timeout in seconds
+            "max_buffer_size": 1048576,  # 1MB max output buffer
+            "max_results": 100,  # Maximum results per search
+            "enable_metrics": False,  # Enable performance metrics collection
+            "debug": False,  # Enable debug logging for ripgrep operations
+        },
     },
     "mcpServers": {},
 }

tunacode/constants.py

@@ -9,7 +9,7 @@ from enum import Enum
 
 # Application info
 APP_NAME = "TunaCode"
-APP_VERSION = "0.0.56"
+APP_VERSION = "0.0.57"
 
 
 # File patterns
@@ -60,7 +60,13 @@ TOOL_TODO = ToolName.TODO
 TOOL_EXIT_PLAN_MODE = ToolName.EXIT_PLAN_MODE
 
 # Tool categorization
-READ_ONLY_TOOLS = [ToolName.READ_FILE, ToolName.GREP, ToolName.LIST_DIR, ToolName.GLOB, ToolName.EXIT_PLAN_MODE]
+READ_ONLY_TOOLS = [
+    ToolName.READ_FILE,
+    ToolName.GREP,
+    ToolName.LIST_DIR,
+    ToolName.GLOB,
+    ToolName.EXIT_PLAN_MODE,
+]
 WRITE_TOOLS = [ToolName.WRITE_FILE, ToolName.UPDATE_FILE]
 EXECUTE_TOOLS = [ToolName.BASH, ToolName.RUN_COMMAND]
 

tunacode/core/agents/agent_components/agent_config.py

@@ -1,6 +1,7 @@
 """Agent configuration and creation utilities."""
 
 from pathlib import Path
+from typing import Dict, Tuple
 
 from pydantic_ai import Agent
 
@@ -8,10 +9,10 @@ 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.present_plan import create_present_plan_tool
 from tunacode.tools.glob import glob
 from tunacode.tools.grep import grep
 from tunacode.tools.list_dir import list_dir
+from tunacode.tools.present_plan import create_present_plan_tool
 from tunacode.tools.read_file import read_file
 from tunacode.tools.run_command import run_command
 from tunacode.tools.todo import TodoTool
@@ -21,6 +22,22 @@ from tunacode.types import ModelName, PydanticAgent
 
 logger = get_logger(__name__)
 
+# Module-level caches for system prompts
+_PROMPT_CACHE: Dict[str, Tuple[str, float]] = {}
+_TUNACODE_CACHE: Dict[str, Tuple[str, float]] = {}
+
+# Module-level cache for agents to persist across requests
+_AGENT_CACHE: Dict[ModelName, PydanticAgent] = {}
+_AGENT_CACHE_VERSION: Dict[ModelName, int] = {}
+
+
+def clear_all_caches():
+    """Clear all module-level caches. Useful for testing."""
+    _PROMPT_CACHE.clear()
+    _TUNACODE_CACHE.clear()
+    _AGENT_CACHE.clear()
+    _AGENT_CACHE_VERSION.clear()
+
 
 def get_agent_tool():
     """Lazy import for Agent and Tool to avoid circular imports."""
@@ -30,47 +47,114 @@ def get_agent_tool():
 
 
 def load_system_prompt(base_path: Path) -> str:
-    """Load the system prompt from file."""
+    """Load the system prompt from file with caching."""
     prompt_path = base_path / "prompts" / "system.md"
+    cache_key = str(prompt_path)
+
+    # Check cache with file modification time
     try:
+        if cache_key in _PROMPT_CACHE:
+            cached_content, cached_mtime = _PROMPT_CACHE[cache_key]
+            current_mtime = prompt_path.stat().st_mtime
+            if current_mtime == cached_mtime:
+                return cached_content
+
+        # Load from file and cache
         with open(prompt_path, "r", encoding="utf-8") as f:
-            return f.read().strip()
+            content = f.read().strip()
+        _PROMPT_CACHE[cache_key] = (content, prompt_path.stat().st_mtime)
+        return content
+
     except FileNotFoundError:
         # Fallback to system.txt if system.md not found
         prompt_path = base_path / "prompts" / "system.txt"
+        cache_key = str(prompt_path)
+
         try:
+            if cache_key in _PROMPT_CACHE:
+                cached_content, cached_mtime = _PROMPT_CACHE[cache_key]
+                current_mtime = prompt_path.stat().st_mtime
+                if current_mtime == cached_mtime:
+                    return cached_content
+
             with open(prompt_path, "r", encoding="utf-8") as f:
-                return f.read().strip()
+                content = f.read().strip()
+            _PROMPT_CACHE[cache_key] = (content, prompt_path.stat().st_mtime)
+            return content
+
         except FileNotFoundError:
             # Use a default system prompt if neither file exists
-            return "You are a helpful AI assistant for software development tasks."
+            return "You are a helpful AI assistant."
 
 
 def load_tunacode_context() -> str:
-    """Load TUNACODE.md context if it exists."""
+    """Load TUNACODE.md context if it exists with caching."""
     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")
+        cache_key = str(tunacode_path)
+
+        if not tunacode_path.exists():
+            logger.info("📄 TUNACODE.md not found: Using default context")
+            return ""
+
+        # Check cache with file modification time
+        if cache_key in _TUNACODE_CACHE:
+            cached_content, cached_mtime = _TUNACODE_CACHE[cache_key]
+            current_mtime = tunacode_path.stat().st_mtime
+            if current_mtime == cached_mtime:
+                return cached_content
+
+        # Load from file and cache
+        tunacode_content = tunacode_path.read_text(encoding="utf-8")
+        if tunacode_content.strip():
+            logger.info("📄 TUNACODE.md located: Loading context...")
+            result = "\n\n# Project Context from TUNACODE.md\n" + tunacode_content
+            _TUNACODE_CACHE[cache_key] = (result, tunacode_path.stat().st_mtime)
+            return result
         else:
             logger.info("📄 TUNACODE.md not found: Using default context")
+            _TUNACODE_CACHE[cache_key] = ("", tunacode_path.stat().st_mtime)
+            return ""
+
     except Exception as e:
         logger.debug(f"Error loading TUNACODE.md: {e}")
-    return ""
+        return ""
 
 
 def get_or_create_agent(model: ModelName, state_manager: StateManager) -> PydanticAgent:
     """Get existing agent or create new one for the specified model."""
     import logging
+
     logger = logging.getLogger(__name__)
-    
-    if model not in state_manager.session.agents:
-        logger.debug(f"Creating new agent for model {model}, plan_mode={state_manager.is_plan_mode()}")
+
+    # Check session-level cache first (for backward compatibility with tests)
+    if model in state_manager.session.agents:
+        logger.debug(f"Using session-cached agent for model {model}")
+        return state_manager.session.agents[model]
+
+    # Check module-level cache
+    if model in _AGENT_CACHE:
+        # Verify cache is still valid (check for config changes)
+        current_version = hash(
+            (
+                state_manager.is_plan_mode(),
+                str(state_manager.session.user_config.get("settings", {}).get("max_retries", 3)),
+                str(state_manager.session.user_config.get("mcpServers", {})),
+            )
+        )
+        if _AGENT_CACHE_VERSION.get(model) == current_version:
+            logger.debug(f"Using module-cached agent for model {model}")
+            state_manager.session.agents[model] = _AGENT_CACHE[model]
+            return _AGENT_CACHE[model]
+        else:
+            logger.debug(f"Cache invalidated for model {model} due to config change")
+            del _AGENT_CACHE[model]
+            del _AGENT_CACHE_VERSION[model]
+
+    if model not in _AGENT_CACHE:
+        logger.debug(
+            f"Creating new agent for model {model}, plan_mode={state_manager.is_plan_mode()}"
+        )
         max_retries = state_manager.session.user_config.get("settings", {}).get("max_retries", 3)
 
         # Lazy import Agent and Tool
@@ -86,56 +170,21 @@ def get_or_create_agent(model: ModelName, state_manager: StateManager) -> Pydant
         # Add plan mode context if in plan mode
         if state_manager.is_plan_mode():
             # REMOVE all TUNACODE_TASK_COMPLETE instructions from the system prompt
-            system_prompt = system_prompt.replace("TUNACODE_TASK_COMPLETE", "PLAN_MODE_TASK_PLACEHOLDER")
+            system_prompt = system_prompt.replace(
+                "TUNACODE_TASK_COMPLETE", "PLAN_MODE_TASK_PLACEHOLDER"
+            )
             # Remove the completion guidance that conflicts with plan mode
             lines_to_remove = [
                 "When a task is COMPLETE, start your response with: TUNACODE_TASK_COMPLETE",
-                "4. When a task is COMPLETE, start your response with: TUNACODE_TASK_COMPLETE", 
+                "4. When a task is COMPLETE, start your response with: TUNACODE_TASK_COMPLETE",
                 "**How to signal completion:**",
                 "TUNACODE_TASK_COMPLETE",
                 "[Your summary of what was accomplished]",
                 "**IMPORTANT**: Always evaluate if you've completed the task. If yes, use TUNACODE_TASK_COMPLETE.",
-                "This prevents wasting iterations and API calls."
+                "This prevents wasting iterations and API calls.",
             ]
             for line in lines_to_remove:
                 system_prompt = system_prompt.replace(line, "")
-            plan_mode_override = """
-🔍 PLAN MODE - YOU MUST USE THE present_plan TOOL 🔍
-
-CRITICAL: You are in Plan Mode. You MUST execute the present_plan TOOL, not show it as text.
-
-❌ WRONG - DO NOT SHOW THE FUNCTION AS TEXT:
-```
-present_plan(title="...", ...)  # THIS IS WRONG - DON'T SHOW AS CODE
-```
-
-✅ CORRECT - ACTUALLY EXECUTE THE TOOL:
-You must EXECUTE present_plan as a tool call, just like you execute read_file or grep.
-
-CRITICAL RULES:
-1. DO NOT show present_plan() as code or text
-2. DO NOT write "Here's the plan" or any text description
-3. DO NOT use TUNACODE_TASK_COMPLETE
-4. DO NOT use markdown code blocks for present_plan
-
-YOU MUST EXECUTE THE TOOL:
-When the user asks you to "plan" something, you must:
-1. Research using read_only tools (optional)
-2. EXECUTE present_plan tool with the plan data
-3. The tool will handle displaying the plan
-
-Example of CORRECT behavior:
-User: "plan a markdown file"
-You: [Execute read_file/grep if needed for research]
-     [Then EXECUTE present_plan tool - not as text but as an actual tool call]
-
-Remember: present_plan is a TOOL like read_file or grep. You must EXECUTE it, not SHOW it.
-
-Available tools:
-- read_file, grep, list_dir, glob: For research
-- present_plan: EXECUTE this tool to present the plan (DO NOT show as text)
-
-"""
             # COMPLETELY REPLACE system prompt in plan mode - nuclear option
             system_prompt = """
 🔧 PLAN MODE - TOOL EXECUTION ONLY 🔧
@@ -146,7 +195,7 @@ CRITICAL: You cannot respond with text. You MUST use tools for everything.
 
 AVAILABLE TOOLS:
 - read_file(filepath): Read file contents
-- grep(pattern): Search for text patterns  
+- grep(pattern): Search for text patterns
 - list_dir(directory): List directory contents
 - glob(pattern): Find files matching patterns
 - present_plan(title, overview, steps, files_to_create, success_criteria): Present structured plan
@@ -170,7 +219,7 @@ You: [Call read_file or grep for research if needed]
 
 The present_plan tool takes these parameters:
 - title: Brief title string
-- overview: What the plan accomplishes  
+- overview: What the plan accomplishes
 - steps: List of implementation steps
 - files_to_create: List of files to create
 - success_criteria: List of success criteria
@@ -215,22 +264,36 @@ YOU MUST EXECUTE present_plan TOOL TO COMPLETE ANY PLANNING TASK.
                 Tool(update_file, max_retries=max_retries),
                 Tool(write_file, max_retries=max_retries),
             ]
-        
+
         # Log which tools are being registered
-        logger.debug(f"Creating agent: plan_mode={state_manager.is_plan_mode()}, tools={len(tools_list)}")
+        logger.debug(
+            f"Creating agent: plan_mode={state_manager.is_plan_mode()}, tools={len(tools_list)}"
+        )
         if state_manager.is_plan_mode():
             logger.debug(f"PLAN MODE TOOLS: {[str(tool) for tool in tools_list]}")
             logger.debug(f"present_plan tool type: {type(present_plan)}")
-        
+
         if "PLAN MODE - YOU MUST USE THE present_plan TOOL" in system_prompt:
             logger.debug("✅ Plan mode instructions ARE in system prompt")
         else:
             logger.debug("❌ Plan mode instructions NOT in system prompt")
-        
-        state_manager.session.agents[model] = Agent(
+
+        agent = Agent(
             model=model,
             system_prompt=system_prompt,
             tools=tools_list,
             mcp_servers=get_mcp_servers(state_manager),
         )
-    return state_manager.session.agents[model]
+
+        # Store in both caches
+        _AGENT_CACHE[model] = agent
+        _AGENT_CACHE_VERSION[model] = hash(
+            (
+                state_manager.is_plan_mode(),
+                str(state_manager.session.user_config.get("settings", {}).get("max_retries", 3)),
+                str(state_manager.session.user_config.get("mcpServers", {})),
+            )
+        )
+        state_manager.session.agents[model] = agent
+
+    return _AGENT_CACHE[model]

tunacode/core/agents/agent_components/node_processor.py

@@ -366,7 +366,9 @@ async def _process_tool_calls(
                                         buffered_part.tool_name == "grep"
                                         and "pattern" in buffered_part.args
                                     ):
-                                        tool_desc += f" → pattern: '{buffered_part.args['pattern']}'"
+                                        tool_desc += (
+                                            f" → pattern: '{buffered_part.args['pattern']}'"
+                                        )
                                         if "include_files" in buffered_part.args:
                                             tool_desc += (
                                                 f", files: '{buffered_part.args['include_files']}'"
@@ -380,7 +382,9 @@ async def _process_tool_calls(
                                         buffered_part.tool_name == "glob"
                                         and "pattern" in buffered_part.args
                                     ):
-                                        tool_desc += f" → pattern: '{buffered_part.args['pattern']}'"
+                                        tool_desc += (
+                                            f" → pattern: '{buffered_part.args['pattern']}'"
+                                        )
                                 await ui.muted(tool_desc)
                             await ui.muted("=" * 60)