tunacode-cli 0.0.56__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

@@ -1,29 +1,108 @@
 """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.ui import console as ui
 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,
@@ -36,7 +115,7 @@ class ExitPlanModeTool(BaseTool):
         success_criteria: List[str] = None,
     ) -> ToolResult:
         """Present the implementation plan and get user approval."""
-        
+
         plan = {
             "title": plan_title,
             "overview": overview,
@@ -45,15 +124,15 @@ class ExitPlanModeTool(BaseTool):
             "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 []
+            "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
@@ -66,7 +145,7 @@ class ExitPlanModeTool(BaseTool):
             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
@@ -78,64 +157,66 @@ class ExitPlanModeTool(BaseTool):
         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']
+                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
 
@@ -143,13 +224,14 @@ class ExitPlanModeTool(BaseTool):
 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,
@@ -162,17 +244,17 @@ def create_exit_plan_mode_tool(state_manager):
     ) -> 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  
+            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
         """
@@ -187,5 +269,5 @@ def create_exit_plan_mode_tool(state_manager):
             testing_approach=testing_approach,
             success_criteria=success_criteria,
         )
-    
-    return exit_plan_mode
+
+    return exit_plan_mode