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

tunacode/services/mcp.py

@@ -7,7 +7,7 @@ Handles MCP server initialization, configuration validation, and client connecti
 
 import os
 from contextlib import asynccontextmanager
-from typing import TYPE_CHECKING, AsyncIterator, List, Optional, Tuple
+from typing import TYPE_CHECKING, AsyncIterator, Dict, List, Optional, Tuple
 
 from pydantic_ai.mcp import MCPServerStdio
 
@@ -19,6 +19,10 @@ if TYPE_CHECKING:
 
     from tunacode.core.state import StateManager
 
+# Module-level cache for MCP server instances
+_MCP_SERVER_CACHE: Dict[str, MCPServerStdio] = {}
+_MCP_CONFIG_HASH: Optional[int] = None
+
 
 class QuietMCPServer(MCPServerStdio):
     """A version of ``MCPServerStdio`` that suppresses *all* output coming from the
@@ -55,27 +59,45 @@ class QuietMCPServer(MCPServerStdio):
 
 
 def get_mcp_servers(state_manager: "StateManager") -> List[MCPServerStdio]:
-    """Load MCP servers from configuration.
+    """Load MCP servers from configuration with caching.
 
     Args:
         state_manager: The state manager containing user configuration
 
     Returns:
-        List of MCP server instances
+        List of MCP server instances (cached when possible)
 
     Raises:
         MCPError: If a server configuration is invalid
     """
+    global _MCP_CONFIG_HASH
+
     mcp_servers: MCPServers = state_manager.session.user_config.get("mcpServers", {})
+
+    # Calculate hash of current config
+    current_hash = hash(str(mcp_servers))
+
+    # Check if config has changed
+    if _MCP_CONFIG_HASH == current_hash and _MCP_SERVER_CACHE:
+        # Return cached servers
+        return list(_MCP_SERVER_CACHE.values())
+
+    # Config changed or first load - clear cache and rebuild
+    _MCP_SERVER_CACHE.clear()
+    _MCP_CONFIG_HASH = current_hash
+
     loaded_servers: List[MCPServerStdio] = []
     MCPServerStdio.log_level = "critical"
 
     for server_name, conf in mcp_servers.items():
         try:
-            # loaded_servers.append(QuietMCPServer(**conf))
-            mcp_instance = MCPServerStdio(**conf)
-            # mcp_instance.log_level = "critical"
-            loaded_servers.append(mcp_instance)
+            # Check if this server is already cached
+            if server_name not in _MCP_SERVER_CACHE:
+                # Create new instance
+                mcp_instance = MCPServerStdio(**conf)
+                _MCP_SERVER_CACHE[server_name] = mcp_instance
+
+            loaded_servers.append(_MCP_SERVER_CACHE[server_name])
         except Exception as e:
             raise MCPError(
                 server_name=server_name,

tunacode/tools/base.py

@@ -5,6 +5,7 @@ for all tools including error handling, UI logging, and ModelRetry support.
 """
 
 from abc import ABC, abstractmethod
+from typing import Any, Dict, Optional
 
 from pydantic_ai.exceptions import ModelRetry
 
@@ -24,6 +25,8 @@ class BaseTool(ABC):
         """
         self.ui = ui_logger
         self.logger = get_logger(self.__class__.__name__)
+        self._prompt_cache: Optional[str] = None
+        self._context: Dict[str, Any] = {}
 
     async def execute(self, *args, **kwargs) -> ToolResult:
         """Execute the tool with error handling and logging.
@@ -138,6 +141,113 @@ class BaseTool(ABC):
         """
         return f"in {self.tool_name}"
 
+    def prompt(self, context: Optional[Dict[str, Any]] = None) -> str:
+        """Generate the prompt for this tool.
+
+        Args:
+            context: Optional context including model, permissions, environment
+
+        Returns:
+            str: The generated prompt for this tool
+        """
+        # Update context if provided
+        if context:
+            self._context.update(context)
+
+        # Check cache if context hasn't changed
+        cache_key = str(sorted(self._context.items()))
+        if self._prompt_cache and cache_key == getattr(self, "_cache_key", None):
+            return self._prompt_cache
+
+        # Generate new prompt
+        prompt = self._generate_prompt()
+
+        # Cache the result
+        self._prompt_cache = prompt
+        self._cache_key = cache_key
+
+        return prompt
+
+    def _generate_prompt(self) -> str:
+        """Generate the actual prompt based on current context.
+
+        Override this method in subclasses to provide tool-specific prompts.
+
+        Returns:
+            str: The generated prompt
+        """
+        # Default prompt generation
+        base_prompt = self._get_base_prompt()
+
+        # Apply model-specific adjustments
+        if "model" in self._context:
+            base_prompt = self._adjust_for_model(base_prompt, self._context["model"])
+
+        # Apply permission-specific adjustments
+        if "permissions" in self._context:
+            base_prompt = self._adjust_for_permissions(base_prompt, self._context["permissions"])
+
+        return base_prompt
+
+    def _get_base_prompt(self) -> str:
+        """Get the base prompt for this tool.
+
+        Override this in subclasses to provide tool-specific base prompts.
+
+        Returns:
+            str: The base prompt template
+        """
+        return f"Execute the {self.tool_name} tool to perform its designated operation."
+
+    def _adjust_for_model(self, prompt: str, model: str) -> str:
+        """Adjust prompt based on the model being used.
+
+        Args:
+            prompt: The base prompt
+            model: The model identifier
+
+        Returns:
+            str: Adjusted prompt
+        """
+        # Default implementation - override in subclasses for specific adjustments
+        return prompt
+
+    def _adjust_for_permissions(self, prompt: str, permissions: Dict[str, Any]) -> str:
+        """Adjust prompt based on permissions.
+
+        Args:
+            prompt: The base prompt
+            permissions: Permission settings
+
+        Returns:
+            str: Adjusted prompt
+        """
+        # Default implementation - override in subclasses for specific adjustments
+        return prompt
+
+    def get_tool_schema(self) -> Dict[str, Any]:
+        """Generate the tool schema for API integration.
+
+        Returns:
+            Dict containing the tool schema in OpenAI function format
+        """
+        return {
+            "name": self.tool_name,
+            "description": self.prompt(),
+            "parameters": self._get_parameters_schema(),
+        }
+
+    @abstractmethod
+    def _get_parameters_schema(self) -> Dict[str, Any]:
+        """Get the parameters schema for this tool.
+
+        Must be implemented by subclasses.
+
+        Returns:
+            Dict containing the JSON schema for tool parameters
+        """
+        pass
+
 
 class FileBasedTool(BaseTool):
     """Base class for tools that work with files.

tunacode/tools/bash.py

@@ -7,10 +7,14 @@ environment variables, timeouts, and improved output handling.
 """
 
 import asyncio
+import logging
 import os
 import subprocess
-from typing import Dict, Optional
+from functools import lru_cache
+from pathlib import Path
+from typing import Any, Dict, List, Optional
 
+import defusedxml.ElementTree as ET
 from pydantic_ai.exceptions import ModelRetry
 
 from tunacode.constants import MAX_COMMAND_OUTPUT
@@ -18,6 +22,8 @@ from tunacode.exceptions import ToolExecutionError
 from tunacode.tools.base import BaseTool
 from tunacode.types import ToolResult
 
+logger = logging.getLogger(__name__)
+
 
 class BashTool(BaseTool):
     """Enhanced shell command execution tool with advanced features."""
@@ -26,6 +32,95 @@ class BashTool(BaseTool):
     def tool_name(self) -> str:
         return "Bash"
 
+    @lru_cache(maxsize=1)
+    def _get_base_prompt(self) -> str:
+        """Load and return the base prompt from XML file.
+
+        Returns:
+            str: The loaded prompt from XML or a default prompt
+        """
+        try:
+            # Load prompt from XML file
+            prompt_file = Path(__file__).parent / "prompts" / "bash_prompt.xml"
+            if prompt_file.exists():
+                tree = ET.parse(prompt_file)
+                root = tree.getroot()
+                description = root.find("description")
+                if description is not None:
+                    return description.text.strip()
+        except Exception as e:
+            logger.warning(f"Failed to load XML prompt for bash: {e}")
+
+        # Fallback to default prompt
+        return (
+            """Executes a given bash command in a persistent shell session with optional timeout"""
+        )
+
+    @lru_cache(maxsize=1)
+    def _get_parameters_schema(self) -> Dict[str, Any]:
+        """Get the parameters schema for bash tool.
+
+        Returns:
+            Dict containing the JSON schema for tool parameters
+        """
+        # Try to load from XML first
+        try:
+            prompt_file = Path(__file__).parent / "prompts" / "bash_prompt.xml"
+            if prompt_file.exists():
+                tree = ET.parse(prompt_file)
+                root = tree.getroot()
+                parameters = root.find("parameters")
+                if parameters is not None:
+                    schema: Dict[str, Any] = {"type": "object", "properties": {}, "required": []}
+                    required_fields: List[str] = []
+
+                    for param in parameters.findall("parameter"):
+                        name = param.get("name")
+                        required = param.get("required", "false").lower() == "true"
+                        param_type = param.find("type")
+                        description = param.find("description")
+
+                        if name and param_type is not None:
+                            prop = {
+                                "type": param_type.text.strip(),
+                                "description": description.text.strip()
+                                if description is not None
+                                else "",
+                            }
+
+                            schema["properties"][name] = prop
+                            if required:
+                                required_fields.append(name)
+
+                    schema["required"] = required_fields
+                    return schema
+        except Exception as e:
+            logger.warning(f"Failed to load parameters from XML for bash: {e}")
+
+        # Fallback to hardcoded schema
+        return {
+            "type": "object",
+            "properties": {
+                "command": {
+                    "type": "string",
+                    "description": "The command to execute",
+                },
+                "description": {
+                    "type": "string",
+                    "description": "Clear, concise description of what this command does",
+                },
+                "timeout": {
+                    "type": "number",
+                    "description": "Optional timeout in milliseconds",
+                },
+                "run_in_background": {
+                    "type": "boolean",
+                    "description": "Set to true to run this command in the background",
+                },
+            },
+            "required": ["command"],
+        }
+
     async def _execute(
         self,
         command: str,

tunacode/tools/exit_plan_mode.py

@@ -0,0 +1,273 @@
+"""Tool for exiting plan mode and presenting implementation plan."""
+
+import logging
+from pathlib import Path
+from typing import Any, Dict, List
+
+import defusedxml.ElementTree as ET
+
+from tunacode.tools.base import BaseTool
+from tunacode.types import ToolResult
+from tunacode.ui import console as ui
+
+logger = logging.getLogger(__name__)
+
+
+class ExitPlanModeTool(BaseTool):
+    """Present implementation plan and exit plan mode."""
+
+    def __init__(self, state_manager, ui_logger=None):
+        """Initialize the exit plan mode tool.
+
+        Args:
+            state_manager: StateManager instance for controlling plan mode state
+            ui_logger: UI logger instance for displaying messages
+        """
+        super().__init__(ui_logger)
+        self.state_manager = state_manager
+
+    @property
+    def tool_name(self) -> str:
+        return "exit_plan_mode"
+
+    def _get_base_prompt(self) -> str:
+        """Load and return the base prompt from XML file.
+
+        Returns:
+            str: The loaded prompt from XML or a default prompt
+        """
+        try:
+            # Load prompt from XML file
+            prompt_file = Path(__file__).parent / "prompts" / "exit_plan_mode_prompt.xml"
+            if prompt_file.exists():
+                tree = ET.parse(prompt_file)
+                root = tree.getroot()
+                description = root.find("description")
+                if description is not None:
+                    return description.text.strip()
+        except Exception as e:
+            logger.warning(f"Failed to load XML prompt for exit_plan_mode: {e}")
+
+        # Fallback to default prompt
+        return """Use this tool when you have finished presenting your plan and are ready to code"""
+
+    def _get_parameters_schema(self) -> Dict[str, Any]:
+        """Get the parameters schema for exit_plan_mode tool.
+
+        Returns:
+            Dict containing the JSON schema for tool parameters
+        """
+        # Try to load from XML first
+        try:
+            prompt_file = Path(__file__).parent / "prompts" / "exit_plan_mode_prompt.xml"
+            if prompt_file.exists():
+                tree = ET.parse(prompt_file)
+                root = tree.getroot()
+                parameters = root.find("parameters")
+                if parameters is not None:
+                    schema: Dict[str, Any] = {"type": "object", "properties": {}, "required": []}
+                    required_fields: List[str] = []
+
+                    for param in parameters.findall("parameter"):
+                        name = param.get("name")
+                        required = param.get("required", "false").lower() == "true"
+                        param_type = param.find("type")
+                        description = param.find("description")
+
+                        if name and param_type is not None:
+                            prop = {
+                                "type": param_type.text.strip(),
+                                "description": description.text.strip()
+                                if description is not None
+                                else "",
+                            }
+
+                            schema["properties"][name] = prop
+                            if required:
+                                required_fields.append(name)
+
+                    schema["required"] = required_fields
+                    return schema
+        except Exception as e:
+            logger.warning(f"Failed to load parameters from XML for exit_plan_mode: {e}")
+
+        # Fallback to hardcoded schema
+        return {
+            "type": "object",
+            "properties": {
+                "plan": {
+                    "type": "string",
+                    "description": "The plan you came up with",
+                },
+            },
+            "required": ["plan"],
+        }
+
+    async def _execute(
+        self,
+        plan_title: str,
+        overview: str,
+        implementation_steps: List[str],
+        files_to_modify: List[str] = None,
+        files_to_create: List[str] = None,
+        risks_and_considerations: List[str] = None,
+        testing_approach: str = None,
+        success_criteria: List[str] = None,
+    ) -> ToolResult:
+        """Present the implementation plan and get user approval."""
+
+        plan = {
+            "title": plan_title,
+            "overview": overview,
+            "files_to_modify": files_to_modify or [],
+            "files_to_create": files_to_create or [],
+            "implementation_steps": implementation_steps,
+            "risks_and_considerations": risks_and_considerations or [],
+            "testing_approach": testing_approach or "Manual testing of functionality",
+            "success_criteria": success_criteria or [],
+        }
+
+        # Present plan to user
+        await self._present_plan(plan)
+
+        # Get user approval
+        approved = await self._get_user_approval()
+
+        # Update state based on user approval
+        if approved:
+            # Store the plan and exit plan mode
+            self.state_manager.set_current_plan(plan)
+            self.state_manager.exit_plan_mode(plan)
+            await ui.success("✅ Plan approved! Exiting Plan Mode.")
+            return "Plan approved and Plan Mode exited. You can now execute the implementation using write tools (write_file, update_file, bash, run_command)."
+        else:
+            # Keep the plan but stay in plan mode
+            self.state_manager.set_current_plan(plan)
+            await ui.warning("❌ Plan rejected. Staying in Plan Mode for further research.")
+            return "Plan rejected. Continue researching and refine your approach. You remain in Plan Mode - only read-only tools are available."
+
+    async def _present_plan(self, plan: Dict[str, Any]) -> None:
+        """Present the plan in a formatted way."""
+        # Build the entire plan output as a single string to avoid UI flooding
+        output = []
+        output.append("")
+        output.append("╭─────────────────────────────────────────────────────────╮")
+        output.append("│                  📋 IMPLEMENTATION PLAN                │")
+        output.append("╰─────────────────────────────────────────────────────────╯")
+        output.append("")
+        output.append(f"🎯 {plan['title']}")
+        output.append("")
+
+        if plan["overview"]:
+            output.append(f"📝 Overview: {plan['overview']}")
+            output.append("")
+
+        # Files section
+        if plan["files_to_modify"]:
+            output.append("📝 Files to Modify:")
+            for f in plan["files_to_modify"]:
+                output.append(f"  • {f}")
+            output.append("")
+
+        if plan["files_to_create"]:
+            output.append("📄 Files to Create:")
+            for f in plan["files_to_create"]:
+                output.append(f"  • {f}")
+            output.append("")
+
+        # Implementation steps
+        output.append("🔧 Implementation Steps:")
+        for i, step in enumerate(plan["implementation_steps"], 1):
+            output.append(f"  {i}. {step}")
+        output.append("")
+
+        # Testing approach
+        if plan["testing_approach"]:
+            output.append(f"🧪 Testing Approach: {plan['testing_approach']}")
+            output.append("")
+
+        # Success criteria
+        if plan["success_criteria"]:
+            output.append("✅ Success Criteria:")
+            for criteria in plan["success_criteria"]:
+                output.append(f"  • {criteria}")
+            output.append("")
+
+        # Risks and considerations
+        if plan["risks_and_considerations"]:
+            output.append("⚠️ Risks & Considerations:")
+            for risk in plan["risks_and_considerations"]:
+                output.append(f"  • {risk}")
+            output.append("")
+
+        # Print everything at once
+        await ui.info("\n".join(output))
+
+    async def _get_user_approval(self) -> bool:
+        """Get user approval for the plan."""
+        try:
+            from prompt_toolkit import PromptSession
+            from prompt_toolkit.patch_stdout import patch_stdout
+
+            session = PromptSession()
+
+            with patch_stdout():
+                response = await session.prompt_async(
+                    "\n🤔 Approve this implementation plan? (y/n): "
+                )
+
+            return response.strip().lower() in ["y", "yes", "approve"]
+        except (KeyboardInterrupt, EOFError):
+            return False
+
+
+def create_exit_plan_mode_tool(state_manager):
+    """
+    Factory function to create exit_plan_mode tool with the correct state manager.
+
+    Args:
+        state_manager: The StateManager instance to use
+
+    Returns:
+        Callable: The exit_plan_mode function bound to the provided state manager
+    """
+
+    async def exit_plan_mode(
+        plan_title: str,
+        overview: str,
+        implementation_steps: List[str],
+        files_to_modify: List[str] = None,
+        files_to_create: List[str] = None,
+        risks_and_considerations: List[str] = None,
+        testing_approach: str = None,
+        success_criteria: List[str] = None,
+    ) -> str:
+        """
+        Present implementation plan and exit plan mode.
+
+        Args:
+            plan_title: Brief title for the implementation plan
+            overview: High-level overview of the changes needed
+            implementation_steps: Ordered list of implementation steps
+            files_to_modify: List of files that need to be modified
+            files_to_create: List of new files to be created
+            risks_and_considerations: Potential risks or important considerations
+            testing_approach: Approach for testing the implementation
+            success_criteria: Criteria for considering the implementation successful
+
+        Returns:
+            str: Result message indicating plan approval status
+        """
+        tool = ExitPlanModeTool(state_manager=state_manager)
+        return await tool._execute(
+            plan_title=plan_title,
+            overview=overview,
+            implementation_steps=implementation_steps,
+            files_to_modify=files_to_modify,
+            files_to_create=files_to_create,
+            risks_and_considerations=risks_and_considerations,
+            testing_approach=testing_approach,
+            success_criteria=success_criteria,
+        )
+
+    return exit_plan_mode