tunacode-cli 0.0.55__py3-none-any.whl → 0.0.57__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

@@ -10,7 +10,7 @@ from tunacode.ui import console as ui
 MSG_REQUEST_COMPLETED = "Request completed"
 
 
-async def display_agent_output(res, enable_streaming: bool) -> None:
+async def display_agent_output(res, enable_streaming: bool, state_manager=None) -> None:
     """Display agent output using guard clauses to flatten nested conditionals."""
     if enable_streaming:
         return
@@ -30,4 +30,24 @@ async def display_agent_output(res, enable_streaming: bool) -> 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",
+        ]
+    ):
+        return
+
     await ui.agent(output)

tunacode/cli/repl_components/tool_executor.py

@@ -59,6 +59,18 @@ async def tool_handler(part, state_manager: StateManager):
         args = parse_args(part.args)
 
         def confirm_func():
+            # Check if tool is blocked in plan mode first
+            if tool_handler_instance.is_tool_blocked_in_plan_mode(part.tool_name):
+                from tunacode.constants import READ_ONLY_TOOLS
+
+                error_msg = (
+                    f"🔍 Plan Mode: Tool '{part.tool_name}' is not available in Plan Mode.\n"
+                    f"Only read-only tools are allowed: {', '.join(READ_ONLY_TOOLS)}\n"
+                    f"Use 'exit_plan_mode' tool to present your plan and exit Plan Mode."
+                )
+                print(f"\n❌ {error_msg}\n")
+                return True  # Abort the tool
+
             if not tool_handler_instance.should_confirm(part.tool_name):
                 return False
             request = tool_handler_instance.create_confirmation_request(part.tool_name, args)

tunacode/configuration/defaults.py

@@ -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.55"
+APP_VERSION = "0.0.57"
 
 
 # File patterns
@@ -44,6 +44,7 @@ class ToolName(str, Enum):
     LIST_DIR = "list_dir"
     GLOB = "glob"
     TODO = "todo"
+    EXIT_PLAN_MODE = "exit_plan_mode"
 
 
 # Tool names (backward compatibility)
@@ -56,9 +57,16 @@ TOOL_GREP = ToolName.GREP
 TOOL_LIST_DIR = ToolName.LIST_DIR
 TOOL_GLOB = ToolName.GLOB
 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]
+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
 
@@ -11,6 +12,7 @@ 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.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
@@ -20,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."""
@@ -29,43 +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."""
-    if model not in state_manager.session.agents:
+    import logging
+
+    logger = logging.getLogger(__name__)
+
+    # 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
@@ -78,8 +167,70 @@ def get_or_create_agent(model: ModelName, state_manager: StateManager) -> Pydant
         # Load TUNACODE.md context
         system_prompt += load_tunacode_context()
 
-        # Initialize todo tool
+        # 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"
+            )
+            # 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",
+                "**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.",
+            ]
+            for line in lines_to_remove:
+                system_prompt = system_prompt.replace(line, "")
+            # COMPLETELY REPLACE system prompt in plan mode - nuclear option
+            system_prompt = """
+🔧 PLAN MODE - TOOL EXECUTION ONLY 🔧
+
+You are a planning assistant that ONLY communicates through tool execution.
+
+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
+- 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
+
+MANDATORY WORKFLOW:
+1. User asks you to plan something
+2. You research using read-only tools (if needed)
+3. You EXECUTE present_plan tool with structured data
+4. DONE
+
+FORBIDDEN:
+- Text responses
+- Showing function calls as code
+- Saying "here is the plan"
+- Any text completion
+
+EXAMPLE:
+User: "plan a markdown file"
+You: [Call read_file or grep for research if needed]
+     [Call present_plan tool with actual parameters - NOT as text]
+
+The present_plan tool takes these parameters:
+- title: Brief title string
+- overview: What the plan accomplishes
+- steps: List of implementation steps
+- files_to_create: List of files to create
+- success_criteria: List of success criteria
+
+YOU MUST EXECUTE present_plan TOOL TO COMPLETE ANY PLANNING TASK.
+"""
+
+        # Initialize tools that need state manager
         todo_tool = TodoTool(state_manager=state_manager)
+        present_plan = create_present_plan_tool(state_manager)
+        logger.debug(f"Tools initialized, present_plan available: {present_plan is not None}")
 
         # Add todo context if available
         try:
@@ -89,12 +240,21 @@ def get_or_create_agent(model: ModelName, state_manager: StateManager) -> Pydant
         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=[
+        # Create tool list based on mode
+        if state_manager.is_plan_mode():
+            # Plan mode: Only read-only tools + present_plan
+            tools_list = [
+                Tool(present_plan, 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),
+            ]
+        else:
+            # Normal mode: All tools
+            tools_list = [
                 Tool(bash, max_retries=max_retries),
+                Tool(present_plan, max_retries=max_retries),
                 Tool(glob, max_retries=max_retries),
                 Tool(grep, max_retries=max_retries),
                 Tool(list_dir, max_retries=max_retries),
@@ -103,7 +263,37 @@ def get_or_create_agent(model: ModelName, state_manager: StateManager) -> Pydant
                 Tool(todo_tool._execute, max_retries=max_retries),
                 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)}"
+        )
+        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")
+
+        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]