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

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"
@@ -45,6 +144,7 @@ class RunCommandTool(BaseTool):
             CommandSecurityError: If command fails security validation
             Exception: Any command execution errors
         """
+        process = None
         try:
             # Use secure subprocess execution with validation
             process = safe_subprocess_popen(
@@ -59,6 +159,20 @@ class RunCommandTool(BaseTool):
         except CommandSecurityError as e:
             # Security validation failed - return error without execution
             return f"Security validation failed: {str(e)}"
+        finally:
+            # Ensure process cleanup regardless of success or failure
+            if process is not None and process.poll() is None:
+                try:
+                    # Multi-stage escalation: graceful → terminate → kill
+                    process.terminate()
+                    try:
+                        process.wait(timeout=5.0)
+                    except subprocess.TimeoutExpired:
+                        process.kill()
+                        process.wait(timeout=1.0)
+                except Exception as cleanup_error:
+                    self.logger.warning(f"Failed to cleanup process: {cleanup_error}")
+
         output = stdout.strip() or CMD_OUTPUT_NO_OUTPUT
         error = stderr.strip() or CMD_OUTPUT_NO_ERRORS
         resp = CMD_OUTPUT_FORMAT.format(output=output, error=error).strip()

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)

tunacode/tools/update_file.py

@@ -5,14 +5,21 @@ File update tool for agent operations in the TunaCode application.
 Provides targeted file content modification with diff-based updates.
 """
 
+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 pydantic_ai.exceptions import ModelRetry
 
 from tunacode.exceptions import ToolExecutionError
 from tunacode.tools.base import FileBasedTool
 from tunacode.types import ToolResult
 
+logger = logging.getLogger(__name__)
+
 
 class UpdateFileTool(FileBasedTool):
     """Tool for updating existing files by replacing text blocks."""
@@ -21,6 +28,93 @@ class UpdateFileTool(FileBasedTool):
     def tool_name(self) -> str:
         return "Update"
 
+    @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" / "update_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 update_file: {e}")
+
+        # Fallback to default prompt
+        return """Performs exact string replacements in files"""
+
+    @lru_cache(maxsize=1)
+    def _get_parameters_schema(self) -> Dict[str, Any]:
+        """Get the parameters schema for update_file tool.
+
+        Returns:
+            Dict containing the JSON schema for tool parameters
+        """
+        # Try to load from XML first
+        try:
+            prompt_file = Path(__file__).parent / "prompts" / "update_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 update_file: {e}")
+
+        # Fallback to hardcoded schema
+        return {
+            "type": "object",
+            "properties": {
+                "file_path": {
+                    "type": "string",
+                    "description": "The absolute path to the file to modify",
+                },
+                "old_string": {
+                    "type": "string",
+                    "description": "The text to replace",
+                },
+                "new_string": {
+                    "type": "string",
+                    "description": "The text to replace it with",
+                },
+                "replace_all": {
+                    "type": "boolean",
+                    "description": "Replace all occurences of old_string",
+                },
+            },
+            "required": ["file_path", "old_string", "new_string"],
+        }
+
     async def _execute(self, filepath: str, target: str, patch: str) -> ToolResult:
         """Update an existing file by replacing a target text block with a patch.
 

tunacode/tools/write_file.py

@@ -5,14 +5,21 @@ File writing tool for agent operations in the TunaCode application.
 Provides safe file creation with conflict detection and encoding handling.
 """
 
+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 pydantic_ai.exceptions import ModelRetry
 
 from tunacode.exceptions import ToolExecutionError
 from tunacode.tools.base import FileBasedTool
 from tunacode.types import ToolResult
 
+logger = logging.getLogger(__name__)
+
 
 class WriteFileTool(FileBasedTool):
     """Tool for writing content to new files."""
@@ -21,6 +28,85 @@ class WriteFileTool(FileBasedTool):
     def tool_name(self) -> str:
         return "Write"
 
+    @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" / "write_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 write_file: {e}")
+
+        # Fallback to default prompt
+        return """Writes a file to the local filesystem"""
+
+    @lru_cache(maxsize=1)
+    def _get_parameters_schema(self) -> Dict[str, Any]:
+        """Get the parameters schema for write_file tool.
+
+        Returns:
+            Dict containing the JSON schema for tool parameters
+        """
+        # Try to load from XML first
+        try:
+            prompt_file = Path(__file__).parent / "prompts" / "write_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 write_file: {e}")
+
+        # Fallback to hardcoded schema
+        return {
+            "type": "object",
+            "properties": {
+                "file_path": {
+                    "type": "string",
+                    "description": "The absolute path to the file to write",
+                },
+                "content": {
+                    "type": "string",
+                    "description": "The content to write to the file",
+                },
+            },
+            "required": ["file_path", "content"],
+        }
+
     async def _execute(self, filepath: str, content: str) -> ToolResult:
         """Write content to a new file. Fails if the file already exists.