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

tests/test_adapter_simple.py

@@ -0,0 +1,79 @@
+#!/usr/bin/env python3
+"""Simple test script to verify OutputAdapter pattern works correctly"""
+
+import asyncio
+import pytest
+from unittest.mock import patch, AsyncMock
+from rich.console import Console
+from minion_code.adapters import RichOutputAdapter
+
+
+class MockAgent:
+    """Mock agent for testing"""
+
+    def __init__(self):
+        self._conversation_history = [
+            {"user_message": "Hello", "agent_response": "Hi there!"},
+            {"user_message": "How are you?", "agent_response": "I'm doing well!"},
+            {"user_message": "Test message", "agent_response": "Test response"},
+        ]
+        self.tools = []
+
+    def get_conversation_history(self):
+        return self._conversation_history
+
+    def clear_conversation_history(self):
+        self._conversation_history.clear()
+
+
+@pytest.mark.asyncio
+async def test_adapter():
+    """Test the adapter pattern"""
+    console = Console(force_terminal=False)  # Disable terminal features for testing
+
+    # Test 1: Create adapter
+    output_adapter = RichOutputAdapter(console)
+    assert output_adapter is not None
+    assert output_adapter.console is console
+
+    # Test 2: Test panel method (should not raise)
+    output_adapter.panel(
+        "This is a test panel message", title="Test Panel", border_style="green"
+    )
+
+    # Test 3: Test table method
+    headers = ["Column 1", "Column 2", "Column 3"]
+    rows = [["Data 1", "Data 2", "Data 3"], ["Row 2-1", "Row 2-2", "Row 2-3"]]
+    output_adapter.table(headers, rows, title="Test Table")
+
+    # Test 4: Test text method
+    output_adapter.text("This is simple text output")
+
+    # Test 5: Test command with adapter
+    from minion_code.commands.clear_command import ClearCommand
+
+    mock_agent = MockAgent()
+    clear_command = ClearCommand(output_adapter, mock_agent)
+
+    assert len(mock_agent.get_conversation_history()) == 3
+    await clear_command.execute("--force")
+    assert len(mock_agent.get_conversation_history()) == 0
+
+    # Test 6: Test confirm method with mock (avoid stdin)
+    with patch("rich.prompt.Confirm.ask", return_value=True):
+        result = await output_adapter.confirm(
+            "Do you want to continue?",
+            title="Test Confirmation",
+            ok_text="Yes",
+            cancel_text="No",
+        )
+        assert result is True
+
+    # Test 7: Test confirm returns False when user declines
+    with patch("rich.prompt.Confirm.ask", return_value=False):
+        result = await output_adapter.confirm("Continue?")
+        assert result is False
+
+
+if __name__ == "__main__":
+    asyncio.run(test_adapter())

tests/test_file_read_tool.py

@@ -0,0 +1,144 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""
+Tests for FileReadTool with image support and format_for_observation
+"""
+
+import os
+import tempfile
+from pathlib import Path
+import pytest
+
+# Import the tool
+import sys
+
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), ".."))
+from minion_code.tools.file_read_tool import FileReadTool
+
+try:
+    from PIL import Image
+
+    HAS_PIL = True
+except ImportError:
+    HAS_PIL = False
+
+
+class TestFileReadTool:
+    """Test FileReadTool functionality"""
+
+    def setup_method(self):
+        """Setup test fixtures"""
+        self.tool = FileReadTool()
+        self.temp_dir = tempfile.mkdtemp()
+
+    def teardown_method(self):
+        """Cleanup test fixtures"""
+        import shutil
+
+        if os.path.exists(self.temp_dir):
+            shutil.rmtree(self.temp_dir)
+
+    def test_read_text_file(self):
+        """Test reading a text file"""
+        # Create test file
+        test_file = os.path.join(self.temp_dir, "test.txt")
+        with open(test_file, "w") as f:
+            f.write("Line 1\nLine 2\nLine 3\n")
+
+        # Read file
+        result = self.tool.forward(test_file)
+        assert isinstance(result, str)
+        assert "Line 1" in result
+        assert "Line 2" in result
+        assert "Line 3" in result
+
+    def test_format_for_observation_text(self):
+        """Test format_for_observation with text content"""
+        # Create test file
+        test_file = os.path.join(self.temp_dir, "test.txt")
+        with open(test_file, "w") as f:
+            f.write("Line 1\nLine 2\nLine 3\n")
+
+        # Read file
+        result = self.tool.forward(test_file)
+
+        # Format for observation
+        formatted = self.tool.format_for_observation(result)
+
+        # Check that line numbers are present
+        assert "1→" in formatted or "    1→" in formatted
+        assert "2→" in formatted or "    2→" in formatted
+        assert "3→" in formatted or "    3→" in formatted
+        assert test_file in formatted
+        assert "Total lines:" in formatted
+
+    def test_format_for_observation_with_offset(self):
+        """Test format_for_observation with offset parameter"""
+        # Create test file
+        test_file = os.path.join(self.temp_dir, "test.txt")
+        with open(test_file, "w") as f:
+            f.write("Line 1\nLine 2\nLine 3\nLine 4\nLine 5\n")
+
+        # Read file with offset
+        result = self.tool.forward(test_file, offset=2, limit=2)
+
+        # Format for observation
+        formatted = self.tool.format_for_observation(result)
+
+        # Check that line numbers start from offset
+        assert "3→" in formatted or "    3→" in formatted
+        assert "4→" in formatted or "    4→" in formatted
+        # Should not contain line 1 and 2
+        assert "Line 1" not in result
+        assert "Line 2" not in result
+
+    @pytest.mark.skipif(not HAS_PIL, reason="PIL not available")
+    def test_read_image_file(self):
+        """Test reading an image file"""
+        # Create a simple test image
+        test_image = os.path.join(self.temp_dir, "test.png")
+        img = Image.new("RGB", (100, 100), color="red")
+        img.save(test_image)
+
+        # Read image
+        result = self.tool.forward(test_image)
+
+        # Should return PIL Image object
+        assert isinstance(result, Image.Image)
+        assert result.size == (100, 100)
+
+    @pytest.mark.skipif(not HAS_PIL, reason="PIL not available")
+    def test_format_for_observation_image(self):
+        """Test format_for_observation with image"""
+        # Create a simple test image
+        test_image = os.path.join(self.temp_dir, "test.png")
+        img = Image.new("RGB", (100, 100), color="blue")
+        img.save(test_image)
+
+        # Read image
+        result = self.tool.forward(test_image)
+
+        # Format for observation
+        formatted = self.tool.format_for_observation(result)
+
+        # Check that it contains base64 encoding
+        assert "base64" in formatted.lower()
+        assert "100x100" in formatted
+        assert test_image in formatted
+        assert "Image file:" in formatted
+
+    def test_nonexistent_file(self):
+        """Test reading a nonexistent file"""
+        result = self.tool.forward("/nonexistent/file.txt")
+        assert "Error" in result
+        assert "does not exist" in result
+
+    def test_error_format_for_observation(self):
+        """Test that errors are passed through format_for_observation"""
+        result = self.tool.forward("/nonexistent/file.txt")
+        formatted = self.tool.format_for_observation(result)
+        assert "Error" in formatted
+
+
+if __name__ == "__main__":
+    pytest.main([__file__, "-v"])

tests/test_readonly_tools.py

@@ -18,7 +18,6 @@ from minion_code.tools import (
     WikipediaSearchTool,
     VisitWebpageTool,
     UserInputTool,
-
 )
 
 
@@ -75,7 +74,6 @@ def test_visit_webpage_tool():
     assert "https://www.example.com" in result
 
 
-
 def test_tool_inheritance():
     """测试所有工具都正确继承了 BaseTool"""
     from minion.tools import BaseTool

tests/test_skills.py

@@ -0,0 +1,441 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Tests for the skills system.
+"""
+
+import pytest
+from pathlib import Path
+import tempfile
+import shutil
+
+from minion_code.skills.skill import Skill
+from minion_code.skills.skill_registry import (
+    SkillRegistry,
+    get_skill_registry,
+    reset_skill_registry,
+)
+from minion_code.skills.skill_loader import SkillLoader
+
+
+class TestSkill:
+    """Tests for the Skill class."""
+
+    def test_parse_frontmatter_basic(self):
+        """Test parsing basic YAML frontmatter."""
+        content = """---
+name: test-skill
+description: A test skill for testing purposes
+---
+
+# Test Skill Instructions
+
+This is the skill content.
+"""
+        frontmatter, body = Skill._parse_frontmatter(content)
+
+        assert frontmatter["name"] == "test-skill"
+        assert frontmatter["description"] == "A test skill for testing purposes"
+        assert "# Test Skill Instructions" in body
+
+    def test_parse_frontmatter_with_optional_fields(self):
+        """Test parsing frontmatter with optional fields."""
+        content = """---
+name: advanced-skill
+description: An advanced skill
+license: MIT
+allowed-tools:
+  - Bash
+  - Read
+metadata:
+  author: test
+  version: "1.0"
+---
+
+Instructions here.
+"""
+        frontmatter, body = Skill._parse_frontmatter(content)
+
+        assert frontmatter["name"] == "advanced-skill"
+        assert frontmatter["license"] == "MIT"
+        assert frontmatter["allowed-tools"] == ["Bash", "Read"]
+        assert frontmatter["metadata"]["author"] == "test"
+
+    def test_parse_frontmatter_no_frontmatter(self):
+        """Test parsing content without frontmatter."""
+        content = "# Just regular markdown\n\nNo frontmatter here."
+        frontmatter, body = Skill._parse_frontmatter(content)
+
+        assert frontmatter == {}
+        assert body == content
+
+    def test_from_skill_md(self, tmp_path):
+        """Test creating Skill from SKILL.md file."""
+        # Create a temporary skill directory
+        skill_dir = tmp_path / "my-skill"
+        skill_dir.mkdir()
+
+        skill_md = skill_dir / "SKILL.md"
+        skill_md.write_text(
+            """---
+name: my-skill
+description: My custom skill for testing
+---
+
+# My Skill
+
+Follow these instructions to use my skill.
+
+## Steps
+1. Do this
+2. Then that
+"""
+        )
+
+        skill = Skill.from_skill_md(skill_md, location="project")
+
+        assert skill is not None
+        assert skill.name == "my-skill"
+        assert skill.description == "My custom skill for testing"
+        assert skill.location == "project"
+        assert "# My Skill" in skill.content
+        assert skill.path == skill_dir
+
+    def test_from_skill_md_missing_required_fields(self, tmp_path):
+        """Test that skills without required fields return None."""
+        skill_dir = tmp_path / "bad-skill"
+        skill_dir.mkdir()
+
+        skill_md = skill_dir / "SKILL.md"
+        skill_md.write_text(
+            """---
+name: incomplete-skill
+# Missing description!
+---
+
+Some content.
+"""
+        )
+
+        skill = Skill.from_skill_md(skill_md)
+        assert skill is None
+
+    def test_to_xml(self):
+        """Test XML output format."""
+        skill = Skill(
+            name="xml-test",
+            description="Test XML output",
+            content="Content here",
+            path=Path("/tmp/test"),
+            location="user",
+        )
+
+        xml = skill.to_xml()
+
+        assert "<skill>" in xml
+        assert "<name>xml-test</name>" in xml
+        assert "<description>Test XML output</description>" in xml
+        assert "<location>user</location>" in xml
+
+    def test_get_prompt_includes_base_directory(self, tmp_path):
+        """Test that get_prompt includes the base directory header."""
+        skill_path = tmp_path / "my-skill"
+        skill = Skill(
+            name="test-skill",
+            description="Test skill",
+            content="# Instructions\n\nDo this.",
+            path=skill_path,
+            location="project",
+        )
+
+        prompt = skill.get_prompt()
+
+        assert "Loading: test-skill" in prompt
+        assert f"Base directory: {skill_path}" in prompt
+        assert "# Instructions" in prompt
+        assert "Do this." in prompt
+
+
+class TestSkillRegistry:
+    """Tests for the SkillRegistry class."""
+
+    def setup_method(self):
+        """Reset registry before each test."""
+        reset_skill_registry()
+
+    def test_register_and_get(self):
+        """Test registering and retrieving skills."""
+        registry = SkillRegistry()
+
+        skill = Skill(
+            name="test",
+            description="Test skill",
+            content="Content",
+            path=Path("/tmp"),
+            location="project",
+        )
+
+        result = registry.register(skill)
+        assert result is True
+        assert registry.get("test") == skill
+
+    def test_priority_project_over_user(self):
+        """Test that project skills override user skills."""
+        registry = SkillRegistry()
+
+        user_skill = Skill(
+            name="same-name",
+            description="User version",
+            content="User content",
+            path=Path("/home/user"),
+            location="user",
+        )
+
+        project_skill = Skill(
+            name="same-name",
+            description="Project version",
+            content="Project content",
+            path=Path("/project"),
+            location="project",
+        )
+
+        # Register user skill first
+        registry.register(user_skill)
+        # Then register project skill - should override
+        registry.register(project_skill)
+
+        retrieved = registry.get("same-name")
+        assert retrieved.description == "Project version"
+
+    def test_priority_user_does_not_override_project(self):
+        """Test that user skills don't override project skills."""
+        registry = SkillRegistry()
+
+        project_skill = Skill(
+            name="same-name",
+            description="Project version",
+            content="Project content",
+            path=Path("/project"),
+            location="project",
+        )
+
+        user_skill = Skill(
+            name="same-name",
+            description="User version",
+            content="User content",
+            path=Path("/home/user"),
+            location="user",
+        )
+
+        # Register project skill first
+        registry.register(project_skill)
+        # Try to register user skill - should be skipped
+        result = registry.register(user_skill)
+
+        assert result is False
+        retrieved = registry.get("same-name")
+        assert retrieved.description == "Project version"
+
+    def test_list_all(self):
+        """Test listing all skills."""
+        registry = SkillRegistry()
+
+        for i in range(3):
+            skill = Skill(
+                name=f"skill-{i}",
+                description=f"Skill {i}",
+                content="Content",
+                path=Path("/tmp"),
+                location="project",
+            )
+            registry.register(skill)
+
+        all_skills = registry.list_all()
+        assert len(all_skills) == 3
+
+    def test_generate_skills_prompt(self):
+        """Test generating skills prompt."""
+        registry = SkillRegistry()
+
+        skill = Skill(
+            name="prompt-test",
+            description="Test prompt generation",
+            content="Content",
+            path=Path("/tmp"),
+            location="project",
+        )
+        registry.register(skill)
+
+        prompt = registry.generate_skills_prompt()
+
+        assert "<available_skills>" in prompt
+        assert "<name>prompt-test</name>" in prompt
+
+    def test_generate_skills_prompt_respects_budget(self):
+        """Test that prompt generation respects character budget."""
+        registry = SkillRegistry()
+
+        # Add many skills
+        for i in range(100):
+            skill = Skill(
+                name=f"skill-{i:03d}",
+                description="A " * 50,  # Long description
+                content="Content",
+                path=Path("/tmp"),
+                location="project",
+            )
+            registry.register(skill)
+
+        # Small budget should limit output
+        prompt = registry.generate_skills_prompt(char_budget=500)
+        assert len(prompt) < 1000  # Should be limited
+
+
+class TestSkillLoader:
+    """Tests for the SkillLoader class."""
+
+    def test_get_search_paths(self, tmp_path):
+        """Test search path generation."""
+        loader = SkillLoader(project_root=tmp_path)
+        paths = loader.get_search_paths()
+
+        # Should have project and user paths
+        locations = [loc for _, loc in paths]
+        assert "project" in locations
+        assert "user" in locations
+
+    def test_discover_skills(self, tmp_path):
+        """Test skill discovery in directory."""
+        # Create skills directory structure
+        skills_dir = tmp_path / ".claude" / "skills"
+        skills_dir.mkdir(parents=True)
+
+        # Create two skill directories
+        for name in ["skill-a", "skill-b"]:
+            skill_dir = skills_dir / name
+            skill_dir.mkdir()
+            (skill_dir / "SKILL.md").write_text(
+                f"""---
+name: {name}
+description: Test skill {name}
+---
+
+Instructions for {name}.
+"""
+            )
+
+        loader = SkillLoader(project_root=tmp_path)
+        skill_files = loader.discover_skills(skills_dir)
+
+        assert len(skill_files) == 2
+        names = [f.parent.name for f in skill_files]
+        assert "skill-a" in names
+        assert "skill-b" in names
+
+    def test_discover_nested_skills(self, tmp_path):
+        """Test discovery of nested skills (like document-skills/pdf)."""
+        skills_dir = tmp_path / ".claude" / "skills"
+        nested_dir = skills_dir / "document-skills" / "pdf"
+        nested_dir.mkdir(parents=True)
+
+        (nested_dir / "SKILL.md").write_text(
+            """---
+name: pdf
+description: PDF processing skill
+---
+
+PDF instructions.
+"""
+        )
+
+        loader = SkillLoader(project_root=tmp_path)
+        skill_files = loader.discover_skills(skills_dir)
+
+        assert len(skill_files) == 1
+        assert skill_files[0].parent.name == "pdf"
+
+    def test_load_all(self, tmp_path):
+        """Test loading all skills."""
+        # Create skills directory
+        skills_dir = tmp_path / ".claude" / "skills" / "test-skill"
+        skills_dir.mkdir(parents=True)
+
+        (skills_dir / "SKILL.md").write_text(
+            """---
+name: test-skill
+description: A test skill
+---
+
+Test instructions.
+"""
+        )
+
+        reset_skill_registry()
+        loader = SkillLoader(project_root=tmp_path)
+        registry = loader.load_all()
+
+        assert len(registry) >= 1
+        assert registry.exists("test-skill")
+
+
+class TestIntegration:
+    """Integration tests for the skills system."""
+
+    def test_full_workflow(self, tmp_path):
+        """Test complete workflow from skill file to execution."""
+        # Setup
+        reset_skill_registry()
+
+        # Create skill
+        skills_dir = tmp_path / ".minion" / "skills" / "my-workflow"
+        skills_dir.mkdir(parents=True)
+
+        (skills_dir / "SKILL.md").write_text(
+            """---
+name: my-workflow
+description: Custom workflow for data processing
+allowed-tools:
+  - Bash
+  - Read
+---
+
+# My Workflow
+
+This skill helps you process data efficiently.
+
+## Steps
+
+1. Read the input file
+2. Process the data
+3. Write the output
+
+## Example
+
+```bash
+cat input.txt | process | tee output.txt
+```
+"""
+        )
+
+        # Load
+        loader = SkillLoader(project_root=tmp_path)
+        registry = loader.load_all()
+
+        # Verify
+        skill = registry.get("my-workflow")
+        assert skill is not None
+        assert skill.name == "my-workflow"
+        assert "Bash" in skill.allowed_tools
+        assert "# My Workflow" in skill.get_prompt()
+
+        # Test XML output
+        xml = skill.to_xml()
+        assert "my-workflow" in xml
+
+        # Test prompt generation
+        prompt = registry.generate_skills_prompt()
+        assert "my-workflow" in prompt
+
+
+if __name__ == "__main__":
+    pytest.main([__file__, "-v"])