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

tunacode/tools/present_plan.py

@@ -1,29 +1,108 @@
 """Tool for presenting a structured plan and exiting plan mode."""
 
-from typing import List, Optional
+import logging
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+import defusedxml.ElementTree as ET
 
 from tunacode.tools.base import BaseTool
+from tunacode.types import PlanDoc, PlanPhase, ToolResult
 from tunacode.ui import console as ui
-from tunacode.types import ToolResult, PlanDoc, PlanPhase
+
+logger = logging.getLogger(__name__)
 
 
 class PresentPlanTool(BaseTool):
     """Present a structured implementation plan and request user approval."""
-    
+
     def __init__(self, state_manager, ui_logger=None):
         """Initialize the present plan 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 "present_plan"
-    
+
+    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" / "present_plan_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 present_plan: {e}")
+
+        # Fallback to default prompt
+        return """Present a plan to the user for approval before execution"""
+
+    def _get_parameters_schema(self) -> Dict[str, Any]:
+        """Get the parameters schema for present_plan tool.
+
+        Returns:
+            Dict containing the JSON schema for tool parameters
+        """
+        # Try to load from XML first
+        try:
+            prompt_file = Path(__file__).parent / "prompts" / "present_plan_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 present_plan: {e}")
+
+        # Fallback to hardcoded schema
+        return {
+            "type": "object",
+            "properties": {
+                "plan": {
+                    "type": "string",
+                    "description": "The plan to present to the user",
+                },
+            },
+            "required": ["plan"],
+        }
+
     async def _execute(
         self,
         title: str,
@@ -39,7 +118,7 @@ class PresentPlanTool(BaseTool):
         references: List[str] = None,
     ) -> ToolResult:
         """Present the implementation plan for user approval."""
-        
+
         # Create PlanDoc from parameters
         plan_doc = PlanDoc(
             title=title,
@@ -52,21 +131,21 @@ class PresentPlanTool(BaseTool):
             rollback=rollback,
             open_questions=open_questions or [],
             success_criteria=success_criteria or [],
-            references=references or []
+            references=references or [],
         )
-        
+
         # Validate the plan
         is_valid, missing_sections = plan_doc.validate()
         if not is_valid:
             return f"❌ Plan incomplete. Missing sections: {', '.join(missing_sections)}. Continue researching and refining your plan."
-        
+
         # Set plan phase to PLAN_READY and store the plan
         # The REPL will handle displaying the plan when it detects PLAN_READY phase
         self.state_manager.session.plan_phase = PlanPhase.PLAN_READY
         self.state_manager.session.current_plan = plan_doc
-        
+
         return "Plan ready for review. The system will now present it to the user for approval."
-    
+
     async def _present_plan(self, plan_doc: PlanDoc) -> None:
         """Present the plan in a formatted way."""
         output = []
@@ -77,70 +156,70 @@ class PresentPlanTool(BaseTool):
         output.append("")
         output.append(f"🎯 **{plan_doc.title}**")
         output.append("")
-        
+
         if plan_doc.overview:
             output.append(f"📝 **Overview:** {plan_doc.overview}")
             output.append("")
-        
+
         # Files section
         if plan_doc.files_to_modify:
             output.append("📝 **Files to Modify:**")
             for f in plan_doc.files_to_modify:
                 output.append(f"  • {f}")
             output.append("")
-            
+
         if plan_doc.files_to_create:
             output.append("📄 **Files to Create:**")
             for f in plan_doc.files_to_create:
                 output.append(f"  • {f}")
             output.append("")
-        
+
         # Implementation steps
         output.append("🔧 **Implementation Steps:**")
         for i, step in enumerate(plan_doc.steps, 1):
             output.append(f"  {i}. {step}")
         output.append("")
-        
+
         # Testing approach
         if plan_doc.tests:
             output.append("🧪 **Testing Approach:**")
             for test in plan_doc.tests:
                 output.append(f"  • {test}")
             output.append("")
-        
+
         # Success criteria
         if plan_doc.success_criteria:
             output.append("✅ **Success Criteria:**")
             for criteria in plan_doc.success_criteria:
                 output.append(f"  • {criteria}")
             output.append("")
-        
+
         # Risks and considerations
         if plan_doc.risks:
             output.append("⚠️ **Risks & Considerations:**")
             for risk in plan_doc.risks:
                 output.append(f"  • {risk}")
             output.append("")
-        
+
         # Open questions
         if plan_doc.open_questions:
             output.append("❓ **Open Questions:**")
             for question in plan_doc.open_questions:
                 output.append(f"  • {question}")
             output.append("")
-        
+
         # References
         if plan_doc.references:
             output.append("📚 **References:**")
             for ref in plan_doc.references:
                 output.append(f"  • {ref}")
             output.append("")
-        
+
         # Rollback plan
         if plan_doc.rollback:
             output.append(f"🔄 **Rollback Plan:** {plan_doc.rollback}")
             output.append("")
-        
+
         # Print everything at once
         await ui.info("\n".join(output))
 
@@ -148,13 +227,14 @@ class PresentPlanTool(BaseTool):
 def create_present_plan_tool(state_manager):
     """
     Factory function to create present_plan tool with the correct state manager.
-    
+
     Args:
         state_manager: The StateManager instance to use
-        
+
     Returns:
         Callable: The present_plan function bound to the provided state manager
     """
+
     async def present_plan(
         title: str,
         overview: str,
@@ -170,23 +250,23 @@ def create_present_plan_tool(state_manager):
     ) -> str:
         """
         Present a structured implementation plan for user approval.
-        
+
         This tool should ONLY be called when you have a complete, well-researched plan.
         All required sections must be filled out before calling this tool.
-        
+
         Args:
             title: Brief, descriptive title for the implementation plan
             overview: High-level summary of what needs to be implemented and why
             steps: Ordered list of specific implementation steps (required)
             files_to_modify: List of existing files that need to be modified
-            files_to_create: List of new files that need to be created  
+            files_to_create: List of new files that need to be created
             risks: Potential risks, challenges, or considerations
             tests: Testing approach and test cases to validate implementation
             rollback: Plan for reverting changes if needed
             open_questions: Any remaining questions or uncertainties
             success_criteria: Specific criteria for considering the task complete
             references: External resources, documentation, or research sources
-            
+
         Returns:
             str: Status message about plan presentation
         """
@@ -204,5 +284,5 @@ def create_present_plan_tool(state_manager):
             success_criteria=success_criteria,
             references=references,
         )
-    
-    return present_plan
+
+    return present_plan

tunacode/tools/read_file.py

@@ -6,7 +6,13 @@ Provides safe file reading with size limits and proper error handling.
 """
 
 import asyncio
+import logging
 import os
+from functools import lru_cache
+from pathlib import Path
+from typing import Any, Dict, List
+
+import defusedxml.ElementTree as ET
 
 from tunacode.constants import (
     ERROR_FILE_DECODE,
@@ -20,6 +26,8 @@ from tunacode.exceptions import ToolExecutionError
 from tunacode.tools.base import FileBasedTool
 from tunacode.types import ToolResult
 
+logger = logging.getLogger(__name__)
+
 
 class ReadFileTool(FileBasedTool):
     """Tool for reading file contents."""
@@ -28,6 +36,89 @@ class ReadFileTool(FileBasedTool):
     def tool_name(self) -> str:
         return "Read"
 
+    @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" / "read_file_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 read_file: {e}")
+
+        # Fallback to default prompt
+        return """Reads a file from the local filesystem"""
+
+    @lru_cache(maxsize=1)
+    def _get_parameters_schema(self) -> Dict[str, Any]:
+        """Get the parameters schema for read_file tool.
+
+        Returns:
+            Dict containing the JSON schema for tool parameters
+        """
+        # Try to load from XML first
+        try:
+            prompt_file = Path(__file__).parent / "prompts" / "read_file_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 read_file: {e}")
+
+        # Fallback to hardcoded schema
+        return {
+            "type": "object",
+            "properties": {
+                "file_path": {
+                    "type": "string",
+                    "description": "The absolute path to the file to read",
+                },
+                "offset": {
+                    "type": "number",
+                    "description": "The line number to start reading from",
+                },
+                "limit": {
+                    "type": "number",
+                    "description": "The number of lines to read",
+                },
+            },
+            "required": ["file_path"],
+        }
+
     async def _execute(self, filepath: str) -> ToolResult:
         """Read the contents of a file.
 

tunacode/tools/run_command.py

@@ -5,7 +5,13 @@ Command execution tool for agent operations in the TunaCode application.
 Provides controlled shell command execution with output capture and truncation.
 """
 
+import logging
 import subprocess
+from functools import lru_cache
+from pathlib import Path
+from typing import Any, Dict, List
+
+import defusedxml.ElementTree as ET
 
 from tunacode.constants import (
     CMD_OUTPUT_FORMAT,
@@ -23,10 +29,103 @@ from tunacode.tools.base import BaseTool
 from tunacode.types import ToolResult
 from tunacode.utils.security import CommandSecurityError, safe_subprocess_popen
 
+logger = logging.getLogger(__name__)
+
 
 class RunCommandTool(BaseTool):
     """Tool for running shell commands."""
 
+    @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" / "run_command_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 run_command: {e}")
+
+        # Fallback to default prompt
+        return """Executes system commands with enhanced control and monitoring capabilities"""
+
+    @lru_cache(maxsize=1)
+    def _get_parameters_schema(self) -> Dict[str, Any]:
+        """Get the parameters schema for run_command tool.
+
+        Returns:
+            Dict containing the JSON schema for tool parameters
+        """
+        # Try to load from XML first
+        try:
+            prompt_file = Path(__file__).parent / "prompts" / "run_command_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 run_command: {e}")
+
+        # Fallback to hardcoded schema
+        return {
+            "type": "object",
+            "properties": {
+                "command": {
+                    "type": "string",
+                    "description": "The command to execute",
+                },
+                "cwd": {
+                    "type": "string",
+                    "description": "Working directory for the command",
+                },
+                "env": {
+                    "type": "object",
+                    "description": "Additional environment variables",
+                },
+                "timeout": {
+                    "type": "integer",
+                    "description": "Command timeout in seconds",
+                },
+                "capture_output": {
+                    "type": "boolean",
+                    "description": "Whether to capture stdout/stderr",
+                },
+            },
+            "required": ["command"],
+        }
+
     @property
     def tool_name(self) -> str:
         return "Shell"

tunacode/tools/schema_assembler.py

@@ -0,0 +1,167 @@
+"""Tool Schema Assembler for API Integration.
+
+This module handles the assembly of tool schemas for API calls,
+converting tool prompts and parameters into OpenAI-compatible function schemas.
+"""
+
+from typing import Any, Dict, List, Optional, Type
+
+from tunacode.tools.base import BaseTool
+
+
+class ToolSchemaAssembler:
+    """Assembles tool schemas for API integration."""
+
+    def __init__(self):
+        """Initialize the schema assembler."""
+        self._context: Dict[str, Any] = {}
+        self._tool_instances: Dict[str, BaseTool] = {}
+
+    def set_context(self, context: Dict[str, Any]) -> None:
+        """Set the context for all tools.
+
+        Args:
+            context: Context including model, permissions, environment, etc.
+        """
+        self._context = context
+        # Update context for all registered tools
+        for tool in self._tool_instances.values():
+            tool._context.update(context)
+
+    def register_tool(self, tool: BaseTool) -> None:
+        """Register a tool instance.
+
+        Args:
+            tool: The tool instance to register
+        """
+        self._tool_instances[tool.tool_name] = tool
+        # Apply current context to the new tool
+        if self._context:
+            tool._context.update(self._context)
+
+    def register_tool_class(self, tool_class: Type[BaseTool], *args, **kwargs) -> None:
+        """Register a tool by instantiating its class.
+
+        Args:
+            tool_class: The tool class to instantiate
+            *args, **kwargs: Arguments for tool instantiation
+        """
+        tool = tool_class(*args, **kwargs)
+        self.register_tool(tool)
+
+    def get_tool_schema(self, tool_name: str) -> Optional[Dict[str, Any]]:
+        """Get the schema for a specific tool.
+
+        Args:
+            tool_name: Name of the tool
+
+        Returns:
+            Tool schema in OpenAI function format, or None if not found
+        """
+        tool = self._tool_instances.get(tool_name)
+        if not tool:
+            return None
+
+        return tool.get_tool_schema()
+
+    def get_all_schemas(self) -> List[Dict[str, Any]]:
+        """Get schemas for all registered tools.
+
+        Returns:
+            List of tool schemas in OpenAI function format
+        """
+        schemas = []
+        for tool in self._tool_instances.values():
+            schema = tool.get_tool_schema()
+            if schema:
+                schemas.append(schema)
+        return schemas
+
+    def get_schemas_for_model(self, model: str) -> List[Dict[str, Any]]:
+        """Get schemas optimized for a specific model.
+
+        Args:
+            model: The model identifier (e.g., 'claude-3', 'gpt-4')
+
+        Returns:
+            List of tool schemas optimized for the model
+        """
+        # Update context with model
+        self.set_context({"model": model, **self._context})
+
+        # Get all schemas with model-specific prompts
+        return self.get_all_schemas()
+
+    def get_schemas_with_permissions(self, permissions: Dict[str, Any]) -> List[Dict[str, Any]]:
+        """Get schemas filtered by permissions.
+
+        Args:
+            permissions: Permission settings
+
+        Returns:
+            List of tool schemas filtered by permissions
+        """
+        # Update context with permissions
+        self.set_context({"permissions": permissions, **self._context})
+
+        # Filter tools based on permissions
+        schemas = []
+        for tool_name, tool in self._tool_instances.items():
+            # Check if tool is allowed based on permissions
+            if self._is_tool_allowed(tool_name, permissions):
+                schema = tool.get_tool_schema()
+                if schema:
+                    schemas.append(schema)
+
+        return schemas
+
+    def _is_tool_allowed(self, tool_name: str, permissions: Dict[str, Any]) -> bool:
+        """Check if a tool is allowed based on permissions.
+
+        Args:
+            tool_name: Name of the tool
+            permissions: Permission settings
+
+        Returns:
+            True if the tool is allowed
+        """
+        # Default implementation - can be extended
+        if permissions.get("restricted", False):
+            # In restricted mode, only allow safe tools
+            safe_tools = ["read_file", "list_dir", "grep", "glob"]
+            return tool_name in safe_tools
+
+        # Check for explicit tool permissions
+        allowed_tools = permissions.get("allowed_tools")
+        if allowed_tools:
+            return tool_name in allowed_tools
+
+        blocked_tools = permissions.get("blocked_tools", [])
+        return tool_name not in blocked_tools
+
+    def refresh_prompts(self) -> None:
+        """Refresh prompts for all tools based on current context."""
+        for tool in self._tool_instances.values():
+            # Clear prompt cache to force regeneration
+            tool._prompt_cache = None
+
+    def update_environment(self, env_vars: Dict[str, Any]) -> None:
+        """Update environment variables in context.
+
+        Args:
+            env_vars: Environment variables to update
+        """
+        current_env = self._context.get("environment", {})
+        current_env.update(env_vars)
+        self.set_context({"environment": current_env, **self._context})
+
+    def get_tool_by_name(self, tool_name: str) -> Optional[BaseTool]:
+        """Get a tool instance by name.
+
+        Args:
+            tool_name: Name of the tool
+
+        Returns:
+            Tool instance or None if not found
+        """
+        return self._tool_instances.get(tool_name)