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

tunacode/tools/present_plan.py

@@ -0,0 +1,288 @@
+"""Tool for presenting a structured plan and exiting plan mode."""
+
+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
+
+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,
+        overview: str,
+        steps: List[str],
+        files_to_modify: List[str] = None,
+        files_to_create: List[str] = None,
+        risks: List[str] = None,
+        tests: List[str] = None,
+        rollback: Optional[str] = None,
+        open_questions: List[str] = None,
+        success_criteria: List[str] = None,
+        references: List[str] = None,
+    ) -> ToolResult:
+        """Present the implementation plan for user approval."""
+
+        # Create PlanDoc from parameters
+        plan_doc = PlanDoc(
+            title=title,
+            overview=overview,
+            steps=steps,
+            files_to_modify=files_to_modify or [],
+            files_to_create=files_to_create or [],
+            risks=risks or [],
+            tests=tests or [],
+            rollback=rollback,
+            open_questions=open_questions or [],
+            success_criteria=success_criteria 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 = []
+        output.append("")
+        output.append("╭─────────────────────────────────────────────────────────╮")
+        output.append("│                  📋 IMPLEMENTATION PLAN                │")
+        output.append("╰─────────────────────────────────────────────────────────╯")
+        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))
+
+
+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,
+        steps: List[str],
+        files_to_modify: List[str] = None,
+        files_to_create: List[str] = None,
+        risks: List[str] = None,
+        tests: List[str] = None,
+        rollback: Optional[str] = None,
+        open_questions: List[str] = None,
+        success_criteria: List[str] = None,
+        references: List[str] = None,
+    ) -> 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
+            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
+        """
+        tool = PresentPlanTool(state_manager=state_manager)
+        return await tool._execute(
+            title=title,
+            overview=overview,
+            steps=steps,
+            files_to_modify=files_to_modify,
+            files_to_create=files_to_create,
+            risks=risks,
+            tests=tests,
+            rollback=rollback,
+            open_questions=open_questions,
+            success_criteria=success_criteria,
+            references=references,
+        )
+
+    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)