minion-code 0.1.0__py3-none-any.whl → 0.1.2__py3-none-any.whl

minion_code/tools/ls_tool.py

@@ -5,7 +5,9 @@ Directory listing tool
 """
 
 from pathlib import Path
+from typing import Any, Optional
 from minion.tools import BaseTool
+from ..utils.output_truncator import truncate_output
 
 
 class LsTool(BaseTool):
@@ -15,7 +17,11 @@ class LsTool(BaseTool):
     description = "List directory contents"
     readonly = True  # Read-only tool, does not modify system state
     inputs = {
-        "path": {"type": "string", "description": "Directory path to list", "nullable": True},
+        "path": {
+            "type": "string",
+            "description": "Directory path to list",
+            "nullable": True,
+        },
         "recursive": {
             "type": "boolean",
             "description": "Whether to list recursively",
@@ -24,10 +30,23 @@ class LsTool(BaseTool):
     }
     output_type = "string"
 
+    def __init__(self, workdir: Optional[str] = None, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.workdir = Path(workdir) if workdir else None
+
+    def _resolve_path(self, path: str) -> Path:
+        """Resolve path using workdir if path is relative."""
+        p = Path(path)
+        if p.is_absolute():
+            return p
+        if self.workdir:
+            return self.workdir / p
+        return p  # Relative to cwd (backward compatible)
+
     def forward(self, path: str = ".", recursive: bool = False) -> str:
         """List directory contents"""
         try:
-            dir_path = Path(path)
+            dir_path = self._resolve_path(path)
             if not dir_path.exists():
                 return f"Error: Path does not exist - {path}"
 
@@ -59,7 +78,13 @@ class LsTool(BaseTool):
                     else:
                         result += f"  Other: {item.name}\n"
 
-            return result
+            return self.format_for_observation(result)
 
         except Exception as e:
             return f"Error listing directory: {str(e)}"
+
+    def format_for_observation(self, output: Any) -> str:
+        """格式化输出，自动截断过大内容"""
+        if isinstance(output, str):
+            return truncate_output(output, tool_name=self.name)
+        return str(output)

minion_code/tools/multi_edit_tool.py

@@ -8,7 +8,11 @@ import time
 from pathlib import Path
 from typing import Dict, Any, Optional, List
 from minion.tools import BaseTool
-from minion_code.services import record_file_read, record_file_edit, check_file_freshness
+from minion_code.services import (
+    record_file_read,
+    record_file_edit,
+    check_file_freshness,
+)
 
 
 class MultiEditTool(BaseTool):
@@ -16,15 +20,15 @@ class MultiEditTool(BaseTool):
     A tool for making multiple edits to a single file atomically.
     Based on the TypeScript MultiEditTool implementation.
     """
-    
+
     name = "multi_edit"
     description = "A tool for making multiple edits to a single file in one operation"
     readonly = False
-    
+
     inputs = {
         "file_path": {
             "type": "string",
-            "description": "The absolute path to the file to modify"
+            "description": "The absolute path to the file to modify",
         },
         "edits": {
             "type": "array",
@@ -34,23 +38,23 @@ class MultiEditTool(BaseTool):
                 "properties": {
                     "old_string": {
                         "type": "string",
-                        "description": "The text to replace"
+                        "description": "The text to replace",
                     },
                     "new_string": {
-                        "type": "string", 
-                        "description": "The text to replace it with"
+                        "type": "string",
+                        "description": "The text to replace it with",
                     },
                     "replace_all": {
                         "type": "boolean",
-                        "description": "Replace all occurrences of old_string (default: false)"
-                    }
+                        "description": "Replace all occurrences of old_string (default: false)",
+                    },
                 },
-                "required": ["old_string", "new_string"]
-            }
-        }
+                "required": ["old_string", "new_string"],
+            },
+        },
     }
     output_type = "string"
-    
+
     def forward(self, file_path: str, edits: List[Dict[str, Any]]) -> str:
         """Execute multi-edit operation."""
         try:
@@ -58,35 +62,37 @@ class MultiEditTool(BaseTool):
             validation_result = self._validate_input(file_path, edits)
             if not validation_result["valid"]:
                 return f"Error: {validation_result['message']}"
-            
+
             # Apply all edits atomically
             result = self._apply_multi_edit(file_path, edits)
             return result
-            
+
         except Exception as e:
             return f"Error during multi-edit: {str(e)}"
-    
-    def _validate_input(self, file_path: str, edits: List[Dict[str, Any]]) -> Dict[str, Any]:
+
+    def _validate_input(
+        self, file_path: str, edits: List[Dict[str, Any]]
+    ) -> Dict[str, Any]:
         """Validate input parameters."""
-        
+
         # Check if we have edits
         if not edits or len(edits) == 0:
             return {
                 "valid": False,
-                "message": "At least one edit operation is required."
+                "message": "At least one edit operation is required.",
             }
-        
+
         # Resolve absolute path
         if not os.path.isabs(file_path):
             file_path = os.path.abspath(file_path)
-        
+
         # Check if it's a Jupyter notebook
-        if file_path.endswith('.ipynb'):
+        if file_path.endswith(".ipynb"):
             return {
                 "valid": False,
-                "message": "File is a Jupyter Notebook. Use NotebookEdit tool instead."
+                "message": "File is a Jupyter Notebook. Use NotebookEdit tool instead.",
             }
-        
+
         # Handle new file creation
         if not os.path.exists(file_path):
             # For new files, ensure parent directory can be created
@@ -97,14 +103,14 @@ class MultiEditTool(BaseTool):
                 except Exception as e:
                     return {
                         "valid": False,
-                        "message": f"Cannot create parent directory: {str(e)}"
+                        "message": f"Cannot create parent directory: {str(e)}",
                     }
-            
+
             # For new files, first edit must create the file (empty old_string)
             if len(edits) == 0 or edits[0].get("old_string", "") != "":
                 return {
                     "valid": False,
-                    "message": "For new files, the first edit must have an empty old_string to create the file content."
+                    "message": "For new files, the first edit must have an empty old_string to create the file content.",
                 }
         else:
             # For existing files, check freshness
@@ -113,64 +119,61 @@ class MultiEditTool(BaseTool):
                 if freshness_result.conflict:
                     return {
                         "valid": False,
-                        "message": "File has been modified since last read. Read it again before editing."
+                        "message": "File has been modified since last read. Read it again before editing.",
                     }
             except Exception:
                 # If freshness checking fails, continue with basic validation
                 pass
-            
+
             # Check if file is binary
             if self._is_binary_file(file_path):
-                return {
-                    "valid": False,
-                    "message": "Cannot edit binary files."
-                }
-            
+                return {"valid": False, "message": "Cannot edit binary files."}
+
             # Pre-validate that all old_strings exist in the file
             try:
-                with open(file_path, 'r', encoding='utf-8') as f:
+                with open(file_path, "r", encoding="utf-8") as f:
                     current_content = f.read()
-                
+
                 for i, edit in enumerate(edits):
                     old_string = edit.get("old_string", "")
                     if old_string != "" and old_string not in current_content:
                         return {
                             "valid": False,
-                            "message": f"Edit {i + 1}: String to replace not found in file: \"{old_string[:100]}{'...' if len(old_string) > 100 else ''}\""
+                            "message": f"Edit {i + 1}: String to replace not found in file: \"{old_string[:100]}{'...' if len(old_string) > 100 else ''}\"",
                         }
-                        
+
             except UnicodeDecodeError:
                 return {
                     "valid": False,
-                    "message": "Cannot read file - appears to be binary or has encoding issues."
+                    "message": "Cannot read file - appears to be binary or has encoding issues.",
                 }
-        
+
         # Validate each edit
         for i, edit in enumerate(edits):
             old_string = edit.get("old_string", "")
             new_string = edit.get("new_string", "")
-            
+
             if old_string == new_string:
                 return {
                     "valid": False,
-                    "message": f"Edit {i + 1}: old_string and new_string cannot be the same"
+                    "message": f"Edit {i + 1}: old_string and new_string cannot be the same",
                 }
-        
+
         return {"valid": True}
-    
+
     def _apply_multi_edit(self, file_path: str, edits: List[Dict[str, Any]]) -> str:
         """Apply all edits to the file atomically."""
-        
+
         # Resolve absolute path
         if not os.path.isabs(file_path):
             file_path = os.path.abspath(file_path)
-        
+
         # Read current file content (or empty for new files)
         file_exists = os.path.exists(file_path)
-        
+
         if file_exists:
             try:
-                with open(file_path, 'r', encoding='utf-8') as f:
+                with open(file_path, "r", encoding="utf-8") as f:
                     current_content = f.read()
             except UnicodeDecodeError:
                 return "Error: Cannot read file - appears to be binary or has encoding issues."
@@ -178,94 +181,96 @@ class MultiEditTool(BaseTool):
             current_content = ""
             # Ensure parent directory exists
             os.makedirs(os.path.dirname(file_path), exist_ok=True)
-        
+
         # Apply all edits sequentially
         modified_content = current_content
         applied_edits = []
-        
+
         for i, edit in enumerate(edits):
             old_string = edit.get("old_string", "")
             new_string = edit.get("new_string", "")
             replace_all = edit.get("replace_all", False)
-            
+
             try:
                 result = self._apply_content_edit(
                     modified_content, old_string, new_string, replace_all
                 )
                 modified_content = result["new_content"]
-                applied_edits.append({
-                    "edit_index": i + 1,
-                    "success": True,
-                    "old_string": old_string[:100] + ("..." if len(old_string) > 100 else ""),
-                    "new_string": new_string[:100] + ("..." if len(new_string) > 100 else ""),
-                    "occurrences": result["occurrences"]
-                })
-                
+                applied_edits.append(
+                    {
+                        "edit_index": i + 1,
+                        "success": True,
+                        "old_string": old_string[:100]
+                        + ("..." if len(old_string) > 100 else ""),
+                        "new_string": new_string[:100]
+                        + ("..." if len(new_string) > 100 else ""),
+                        "occurrences": result["occurrences"],
+                    }
+                )
+
             except Exception as e:
                 # If any edit fails, abort the entire operation
                 error_message = str(e)
                 return f"Error in edit {i + 1}: {error_message}"
-        
+
         # Write the modified content
         try:
-            with open(file_path, 'w', encoding='utf-8') as f:
+            with open(file_path, "w", encoding="utf-8") as f:
                 f.write(modified_content)
         except Exception as e:
             return f"Error writing file: {str(e)}"
-        
+
         # Record the file edit
         record_file_edit(file_path, modified_content)
-        
+
         # Generate result summary
         operation = "create" if not file_exists else "update"
         summary = f"Successfully applied {len(edits)} edits to {file_path}"
-        
+
         # Add details about each edit
         details = []
         for edit_info in applied_edits:
             details.append(
                 f"Edit {edit_info['edit_index']}: Replaced {edit_info['occurrences']} occurrence(s)"
             )
-        
+
         if details:
             summary += "\n" + "\n".join(details)
-        
+
         return summary
-    
-    def _apply_content_edit(self, content: str, old_string: str, new_string: str, 
-                           replace_all: bool = False) -> Dict[str, Any]:
+
+    def _apply_content_edit(
+        self, content: str, old_string: str, new_string: str, replace_all: bool = False
+    ) -> Dict[str, Any]:
         """Apply a single content edit."""
-        
+
         if replace_all:
             # Replace all occurrences
             import re
+
             # Escape special regex characters in old_string
             escaped_old = re.escape(old_string)
             pattern = re.compile(escaped_old)
             matches = pattern.findall(content)
             occurrences = len(matches)
             new_content = pattern.sub(new_string, content)
-            
-            return {
-                "new_content": new_content,
-                "occurrences": occurrences
-            }
+
+            return {"new_content": new_content, "occurrences": occurrences}
         else:
             # Replace single occurrence
             if old_string in content:
-                new_content = content.replace(old_string, new_string, 1)  # Replace only first occurrence
-                return {
-                    "new_content": new_content,
-                    "occurrences": 1
-                }
+                new_content = content.replace(
+                    old_string, new_string, 1
+                )  # Replace only first occurrence
+                return {"new_content": new_content, "occurrences": 1}
             else:
                 raise Exception(f"String not found: {old_string[:50]}...")
-    
+
     def _is_binary_file(self, file_path: str) -> bool:
         """Check if file is binary."""
         try:
-            with open(file_path, 'rb') as f:
+            with open(file_path, "rb") as f:
                 chunk = f.read(1024)
-                return b'\0' in chunk
+                return b"\0" in chunk
         except Exception:
-            return False
+            return False

minion_code/tools/python_interpreter_tool.py

@@ -7,7 +7,9 @@ Python code execution tool
 import io
 import sys
 from contextlib import redirect_stdout, redirect_stderr
+from typing import Any
 from minion.tools import BaseTool
+from ..utils.output_truncator import truncate_output
 
 
 class PythonInterpreterTool(BaseTool):
@@ -99,7 +101,13 @@ class PythonInterpreterTool(BaseTool):
             if not output_parts:
                 output_parts.append("Code executed successfully, no output.")
 
-            return "\n".join(output_parts)
+            return self.format_for_observation("\n".join(output_parts))
 
         except Exception as e:
             return f"Error executing code: {str(e)}"
+
+    def format_for_observation(self, output: Any) -> str:
+        """格式化输出，自动截断过大内容"""
+        if isinstance(output, str):
+            return truncate_output(output, tool_name=self.name)
+        return str(output)

minion_code/tools/skill_tool.py

@@ -0,0 +1,210 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Skill Tool - executes skills within the conversation.
+
+This tool allows Claude to invoke skills that provide specialized knowledge
+and workflows for specific tasks.
+"""
+
+from typing import Any, Dict, Optional
+from pydantic import Field
+
+from minion.tools import BaseTool
+
+
+class SkillTool(BaseTool):
+    """
+    Tool for executing skills within the main conversation.
+
+    Skills are modular packages that extend Claude's capabilities by providing
+    specialized knowledge, workflows, and tools. When a skill is invoked,
+    its instructions are loaded into the conversation context.
+    """
+
+    name: str = "Skill"
+    description: str = """Execute a skill within the main conversation.
+
+Skills are folders of instructions, scripts, and resources that Claude loads
+dynamically to improve performance on specialized tasks.
+
+Usage:
+- Invoke skills using this tool with the skill name only (no arguments)
+- When you invoke a skill, its prompt will expand and provide detailed instructions
+- Only use skills listed in <available_skills> in the system prompt
+
+Important:
+- Only use skills that are listed as available
+- Do not invoke a skill that is already running
+"""
+
+    parameters: dict = {
+        "type": "object",
+        "properties": {
+            "skill": {
+                "type": "string",
+                "description": "The skill name to execute (e.g., 'pdf', 'xlsx', 'docx')",
+            }
+        },
+        "required": ["skill"],
+    }
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self._registry = None
+
+    @property
+    def registry(self):
+        """Get the skill registry, loading skills if needed."""
+        if self._registry is None:
+            from minion_code.skills import SkillRegistry
+            from minion_code.skills.skill_loader import load_skills
+
+            self._registry = load_skills()
+        return self._registry
+
+    def forward(self, skill: str, **kwargs) -> Dict[str, Any]:
+        """
+        Execute a skill by loading its instructions into the conversation.
+        This is the synchronous entry point required by BaseTool.
+
+        Args:
+            skill: Name of the skill to execute
+
+        Returns:
+            Dict containing the skill prompt and metadata
+        """
+        return self.execute_skill(skill)
+
+    def execute_skill(self, skill: str) -> Dict[str, Any]:
+        """
+        Execute a skill by loading its instructions into the conversation.
+
+        Args:
+            skill: Name of the skill to execute
+
+        Returns:
+            Dict containing the skill prompt and metadata
+        """
+        # Check if skill exists
+        skill_obj = self.registry.get(skill)
+
+        if skill_obj is None:
+            available = [s.name for s in self.registry.list_all()]
+            return {
+                "success": False,
+                "error": f"Unknown skill: {skill}",
+                "available_skills": available[:10],  # Show first 10
+                "hint": "Use one of the available skills listed above",
+            }
+
+        # Get the skill prompt
+        prompt = skill_obj.get_prompt()
+
+        # Build response with skill content
+        return {
+            "success": True,
+            "skill_name": skill_obj.name,
+            "skill_description": skill_obj.description,
+            "skill_location": skill_obj.location,
+            "skill_path": str(
+                skill_obj.path
+            ),  # Absolute path for resolving relative resources
+            "prompt": prompt,
+            "message": f'The "{skill_obj.name}" skill is loading',
+            "allowed_tools": skill_obj.allowed_tools,
+        }
+
+    async def execute(self, skill: str, **kwargs) -> Dict[str, Any]:
+        """
+        Async wrapper for execute_skill.
+
+        Args:
+            skill: Name of the skill to execute
+
+        Returns:
+            Dict containing the skill prompt and metadata
+        """
+        return self.execute_skill(skill)
+
+    def validate_skill(self, skill: str) -> tuple[bool, Optional[str]]:
+        """
+        Validate that a skill exists and can be executed.
+
+        Args:
+            skill: Name of the skill to validate
+
+        Returns:
+            Tuple of (is_valid, error_message)
+        """
+        if not skill:
+            return False, "Skill name is required"
+
+        if not self.registry.exists(skill):
+            available = [s.name for s in self.registry.list_all()]
+            return (
+                False,
+                f"Unknown skill: {skill}. Available: {', '.join(available[:5])}",
+            )
+
+        return True, None
+
+    def get_available_skills_prompt(self, char_budget: int = 10000) -> str:
+        """
+        Generate a prompt listing available skills for the system message.
+
+        Args:
+            char_budget: Maximum characters for skills list
+
+        Returns:
+            Formatted skills prompt
+        """
+        return self.registry.generate_skills_prompt(char_budget)
+
+
+def generate_skill_tool_prompt() -> str:
+    """
+    Generate the complete skill tool prompt including available skills.
+
+    This is used to generate the skill tool description in the system prompt.
+
+    Returns:
+        Complete skill tool prompt
+    """
+    from minion_code.skills.skill_loader import load_skills
+
+    registry = load_skills()
+    skills = registry.list_all()
+
+    if not skills:
+        return """Execute a skill within the main conversation.
+
+No skills are currently available. Skills can be added to:
+- .claude/skills/ (project-level)
+- ~/.claude/skills/ (user-level)
+- .minion/skills/ (project-level)
+- ~/.minion/skills/ (user-level)
+"""
+
+    skills_xml = "\n".join(skill.to_xml() for skill in skills)
+
+    return f"""Execute a skill within the main conversation.
+
+<skills_instructions>
+When users ask you to perform tasks, check if any of the available skills below can help complete the task more effectively. Skills provide specialized capabilities and domain knowledge.
+
+How to use skills:
+- Invoke skills using this tool with the skill name only (no arguments)
+- When you invoke a skill, you will see <command-message>The "{{name}}" skill is loading</command-message>
+- The skill's prompt will expand and provide detailed instructions on how to complete the task
+- Base directory provided in output for resolving bundled resources (references/, scripts/, assets/)
+
+Important:
+- Only use skills listed in <available_skills> below
+- Do not invoke a skill that is already running
+</skills_instructions>
+
+<available_skills>
+{skills_xml}
+</available_skills>
+"""