hud-python 0.3.5__py3-none-any.whl → 0.4.1__py3-none-any.whl

hud/tools/tests/test_computer_actions.py

@@ -1,34 +1,34 @@
-from __future__ import annotations
-
-import pytest
-from mcp.types import ImageContent, TextContent
-
-from hud.tools.computer.hud import HudComputerTool
-
-# (action, kwargs)
-CASES = [
-    ("screenshot", {}),
-    ("click", {"x": 1, "y": 1}),  # Removed pattern=[] to use Field default
-    ("press", {"keys": ["ctrl", "c"]}),
-    ("keydown", {"keys": ["shift"]}),
-    ("keyup", {"keys": ["shift"]}),
-    ("type", {"text": "hello"}),
-    ("scroll", {"x": 10, "y": 10, "scroll_y": 20}),  # Added required x,y coordinates
-    # Skip move test - it has Field parameter handling issues when called directly
-    # ("move", {"x": 5, "y": 5}),  # x,y are for absolute positioning
-    ("wait", {"time": 5}),
-    ("drag", {"path": [(0, 0), (10, 10)]}),
-    ("mouse_down", {}),
-    ("mouse_up", {}),
-    ("hold_key", {"text": "a", "duration": 0.1}),
-]
-
-
-@pytest.mark.asyncio
-@pytest.mark.parametrize("action, params", CASES)
-async def test_hud_computer_actions(action: str, params: dict):
-    comp = HudComputerTool()
-    blocks = await comp(action=action, **params)
-    # Ensure at least one content block is returned
-    assert blocks
-    assert all(isinstance(b, ImageContent | TextContent) for b in blocks)
+from __future__ import annotations
+
+import pytest
+from mcp.types import ImageContent, TextContent
+
+from hud.tools.computer.hud import HudComputerTool
+
+# (action, kwargs)
+CASES = [
+    ("screenshot", {}),
+    ("click", {"x": 1, "y": 1}),  # Removed pattern=[] to use Field default
+    ("press", {"keys": ["ctrl", "c"]}),
+    ("keydown", {"keys": ["shift"]}),
+    ("keyup", {"keys": ["shift"]}),
+    ("type", {"text": "hello"}),
+    ("scroll", {"x": 10, "y": 10, "scroll_y": 20}),  # Added required x,y coordinates
+    # Skip move test - it has Field parameter handling issues when called directly
+    # ("move", {"x": 5, "y": 5}),  # x,y are for absolute positioning
+    ("wait", {"time": 5}),
+    ("drag", {"path": [(0, 0), (10, 10)]}),
+    ("mouse_down", {}),
+    ("mouse_up", {}),
+    ("hold_key", {"text": "a", "duration": 0.1}),
+]
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("action, params", CASES)
+async def test_hud_computer_actions(action: str, params: dict):
+    comp = HudComputerTool()
+    blocks = await comp(action=action, **params)
+    # Ensure at least one content block is returned
+    assert blocks
+    assert all(isinstance(b, ImageContent | TextContent) for b in blocks)

hud/tools/tests/test_edit.py

@@ -1,240 +1,259 @@
-"""Tests for edit tool."""
-
-from __future__ import annotations
-
-import os
-import sys
-import tempfile
-from pathlib import Path
-from unittest.mock import AsyncMock, patch
-
-import pytest
-
-from hud.tools.base import ToolResult
-from hud.tools.edit import EditTool, ToolError
-
-
-class TestEditTool:
-    """Tests for EditTool."""
-
-    def test_edit_tool_init(self):
-        """Test EditTool initialization."""
-        tool = EditTool()
-        assert tool is not None
-        assert tool._file_history == {}
-
-    @pytest.mark.asyncio
-    async def test_validate_path_not_absolute(self):
-        """Test validate_path with non-absolute path."""
-        tool = EditTool()
-
-        with pytest.raises(ToolError) as exc_info:
-            tool.validate_path("create", Path("relative/path.txt"))
-
-        assert "not an absolute path" in str(exc_info.value)
-
-    @pytest.mark.asyncio
-    async def test_validate_path_not_exists(self):
-        """Test validate_path when file doesn't exist for non-create commands."""
-        tool = EditTool()
-
-        # Use a platform-appropriate absolute path
-        if sys.platform == "win32":
-            nonexistent_path = Path("C:\\nonexistent\\file.txt")
-        else:
-            nonexistent_path = Path("/nonexistent/file.txt")
-
-        with pytest.raises(ToolError) as exc_info:
-            tool.validate_path("view", nonexistent_path)
-
-        assert "does not exist" in str(exc_info.value)
-
-    @pytest.mark.asyncio
-    async def test_validate_path_exists_for_create(self):
-        """Test validate_path when file exists for create command."""
-        tool = EditTool()
-
-        with tempfile.NamedTemporaryFile(delete=False) as tmp:
-            tmp_path = Path(tmp.name)
-
-        try:
-            with pytest.raises(ToolError) as exc_info:
-                tool.validate_path("create", tmp_path)
-
-            assert "already exists" in str(exc_info.value)
-        finally:
-            os.unlink(tmp_path)
-
-    @pytest.mark.asyncio
-    async def test_create_file(self):
-        """Test creating a new file."""
-        tool = EditTool()
-
-        with tempfile.TemporaryDirectory() as tmpdir:
-            file_path = Path(tmpdir) / "test.txt"
-            content = "Hello, World!"
-
-            # Mock write_file to avoid actual file I/O
-            with patch.object(tool, "write_file", new_callable=AsyncMock) as mock_write:
-                result = await tool(command="create", path=str(file_path), file_text=content)
-
-                assert isinstance(result, ToolResult)
-                assert result.output is not None
-                assert "created successfully" in result.output
-                mock_write.assert_called_once_with(file_path, content)
-                # Check history
-                assert file_path in tool._file_history
-                assert tool._file_history[file_path] == [content]
-
-    @pytest.mark.asyncio
-    async def test_create_file_no_text(self):
-        """Test creating file without file_text raises error."""
-        tool = EditTool()
-
-        with tempfile.TemporaryDirectory() as tmpdir:
-            file_path = Path(tmpdir) / "test.txt"
-
-            with pytest.raises(ToolError) as exc_info:
-                await tool(command="create", path=str(file_path))
-
-            assert "file_text` is required" in str(exc_info.value)
-
-    @pytest.mark.asyncio
-    async def test_view_file(self):
-        """Test viewing a file."""
-        tool = EditTool()
-
-        file_content = "Line 1\nLine 2\nLine 3"
-
-        # Mock read_file and validate_path
-        with (
-            patch.object(tool, "read_file", new_callable=AsyncMock) as mock_read,
-            patch.object(tool, "validate_path"),
-        ):
-            mock_read.return_value = file_content
-
-            result = await tool(command="view", path="/tmp/test.txt")
-
-            assert isinstance(result, ToolResult)
-            assert result.output is not None
-            assert "Line 1" in result.output
-            assert "Line 2" in result.output
-            assert "Line 3" in result.output
-
-    @pytest.mark.asyncio
-    async def test_view_with_range(self):
-        """Test viewing a file with line range."""
-        tool = EditTool()
-
-        file_content = "\n".join([f"Line {i}" for i in range(1, 11)])
-
-        # Mock read_file and validate_path
-        with (
-            patch.object(tool, "read_file", new_callable=AsyncMock) as mock_read,
-            patch.object(tool, "validate_path"),
-        ):
-            mock_read.return_value = file_content
-
-            result = await tool(command="view", path="/tmp/test.txt", view_range=[3, 5])
-
-            assert isinstance(result, ToolResult)
-            assert result.output is not None
-            # Lines 3-5 should be in output (using tab format)
-            assert "3\tLine 3" in result.output
-            assert "4\tLine 4" in result.output
-            assert "5\tLine 5" in result.output
-            # Line 1 and 10 should not be in output (outside range)
-            assert "1\tLine 1" not in result.output
-            assert "10\tLine 10" not in result.output
-
-    @pytest.mark.asyncio
-    async def test_str_replace_success(self):
-        """Test successful string replacement."""
-        tool = EditTool()
-
-        file_content = "Hello, World!\nThis is a test."
-        expected_content = "Hello, Universe!\nThis is a test."
-
-        # Mock read_file, write_file and validate_path
-        with (
-            patch.object(tool, "read_file", new_callable=AsyncMock) as mock_read,
-            patch.object(tool, "write_file", new_callable=AsyncMock) as mock_write,
-            patch.object(tool, "validate_path"),
-        ):
-            mock_read.return_value = file_content
-
-            result = await tool(
-                command="str_replace", path="/tmp/test.txt", old_str="World", new_str="Universe"
-            )
-
-            assert isinstance(result, ToolResult)
-            assert result.output is not None
-            assert "has been edited" in result.output
-            mock_write.assert_called_once_with(Path("/tmp/test.txt"), expected_content)
-
-    @pytest.mark.asyncio
-    async def test_str_replace_not_found(self):
-        """Test string replacement when old_str not found."""
-        tool = EditTool()
-
-        file_content = "Hello, World!"
-
-        # Mock read_file and validate_path
-        with (
-            patch.object(tool, "read_file", new_callable=AsyncMock) as mock_read,
-            patch.object(tool, "validate_path"),
-        ):
-            mock_read.return_value = file_content
-
-            with pytest.raises(ToolError) as exc_info:
-                await tool(
-                    command="str_replace",
-                    path="/tmp/test.txt",
-                    old_str="Universe",
-                    new_str="Galaxy",
-                )
-
-            assert "did not appear verbatim" in str(exc_info.value)
-
-    @pytest.mark.asyncio
-    async def test_str_replace_multiple_occurrences(self):
-        """Test string replacement with multiple occurrences."""
-        tool = EditTool()
-
-        file_content = "Test test\nAnother test line"
-
-        # Mock read_file and validate_path
-        with (
-            patch.object(tool, "read_file", new_callable=AsyncMock) as mock_read,
-            patch.object(tool, "validate_path"),
-        ):
-            mock_read.return_value = file_content
-
-            with pytest.raises(ToolError) as exc_info:
-                await tool(
-                    command="str_replace", path="/tmp/test.txt", old_str="test", new_str="example"
-                )
-
-            assert "Multiple occurrences" in str(exc_info.value)
-
-    @pytest.mark.asyncio
-    async def test_invalid_command(self):
-        """Test invalid command raises error."""
-        tool = EditTool()
-
-        # Since EditTool has a bug where it references self.name without defining it,
-        # we'll test by passing a Command that isn't in the literal
-        with tempfile.TemporaryDirectory() as tmpdir:
-            file_path = Path(tmpdir) / "test.txt"
-            # Create the file so validate_path doesn't fail
-            file_path.write_text("test content")
-
-            with pytest.raises((ToolError, AttributeError)) as exc_info:
-                await tool(
-                    command="invalid_command",  # type: ignore
-                    path=str(file_path),
-                )
-
-            # Accept either the expected error or AttributeError from the bug
-            error_msg = str(exc_info.value)
-            assert "Unrecognized command" in error_msg or "name" in error_msg
+"""Tests for edit tool."""
+
+from __future__ import annotations
+
+import os
+import sys
+import tempfile
+from pathlib import Path
+from unittest.mock import AsyncMock, patch
+
+import pytest
+from mcp.types import TextContent
+
+from hud.tools.edit import EditTool, ToolError
+
+
+class TestEditTool:
+    """Tests for EditTool."""
+
+    def test_edit_tool_init(self):
+        """Test EditTool initialization."""
+        tool = EditTool()
+        assert tool is not None
+        # File history tracking was removed
+        # assert tool._file_history == {}
+
+    @pytest.mark.asyncio
+    async def test_validate_path_not_absolute(self):
+        """Test validate_path with non-absolute path."""
+        tool = EditTool()
+
+        with pytest.raises(ToolError) as exc_info:
+            tool.validate_path("create", Path("relative/path.txt"))
+
+        assert "not an absolute path" in str(exc_info.value)
+
+    @pytest.mark.asyncio
+    async def test_validate_path_not_exists(self):
+        """Test validate_path when file doesn't exist for non-create commands."""
+        tool = EditTool()
+
+        # Use a platform-appropriate absolute path
+        if sys.platform == "win32":
+            nonexistent_path = Path("C:\\nonexistent\\file.txt")
+        else:
+            nonexistent_path = Path("/nonexistent/file.txt")
+
+        with pytest.raises(ToolError) as exc_info:
+            tool.validate_path("view", nonexistent_path)
+
+        assert "does not exist" in str(exc_info.value)
+
+    @pytest.mark.asyncio
+    async def test_validate_path_exists_for_create(self):
+        """Test validate_path when file exists for create command."""
+        tool = EditTool()
+
+        with tempfile.NamedTemporaryFile(delete=False) as tmp:
+            tmp_path = Path(tmp.name)
+
+        try:
+            with pytest.raises(ToolError) as exc_info:
+                tool.validate_path("create", tmp_path)
+
+            assert "already exists" in str(exc_info.value)
+        finally:
+            os.unlink(tmp_path)
+
+    @pytest.mark.asyncio
+    async def test_create_file(self):
+        """Test creating a new file."""
+        tool = EditTool()
+
+        with tempfile.TemporaryDirectory() as tmpdir:
+            file_path = Path(tmpdir) / "test.txt"
+            content = "Hello, World!"
+
+            # Mock write_file to avoid actual file I/O
+            with patch.object(tool, "write_file", new_callable=AsyncMock) as mock_write:
+                result = await tool(command="create", path=str(file_path), file_text=content)
+
+                assert isinstance(result, list)
+                assert len(result) > 0
+                # Check that we have a content block with the success message
+                assert any("created successfully" in str(block) for block in result)
+                # For TextContent, we need to check the text attribute
+                text_blocks = [block for block in result if isinstance(block, TextContent)]
+                assert len(text_blocks) > 0
+                assert "created successfully" in text_blocks[0].text
+                mock_write.assert_called_once_with(file_path, content)
+                # Check history
+                # File history tracking was removed
+                # assert file_path in tool._file_history
+                # assert tool._file_history[file_path] == [content]
+
+    @pytest.mark.asyncio
+    async def test_create_file_no_text(self):
+        """Test creating file without file_text raises error."""
+        tool = EditTool()
+
+        with tempfile.TemporaryDirectory() as tmpdir:
+            file_path = Path(tmpdir) / "test.txt"
+
+            with pytest.raises(ToolError) as exc_info:
+                await tool(command="create", path=str(file_path))
+
+            assert "file_text` is required" in str(exc_info.value)
+
+    @pytest.mark.asyncio
+    async def test_view_file(self):
+        """Test viewing a file."""
+        tool = EditTool()
+
+        file_content = "Line 1\nLine 2\nLine 3"
+
+        # Mock read_file and validate_path
+        with (
+            patch.object(tool, "read_file", new_callable=AsyncMock) as mock_read,
+            patch.object(tool, "validate_path"),
+        ):
+            mock_read.return_value = file_content
+
+            result = await tool(command="view", path="/tmp/test.txt")
+
+            assert isinstance(result, list)
+            assert len(result) > 0
+            # Check that we have text content blocks with the file contents
+            text_blocks = [block for block in result if isinstance(block, TextContent)]
+            assert len(text_blocks) > 0
+            combined_text = "".join(block.text for block in text_blocks)
+            assert "Line 1" in combined_text
+            assert "Line 2" in combined_text
+            assert "Line 3" in combined_text
+
+    @pytest.mark.asyncio
+    async def test_view_with_range(self):
+        """Test viewing a file with line range."""
+        tool = EditTool()
+
+        file_content = "\n".join([f"Line {i}" for i in range(1, 11)])
+
+        # Mock read_file and validate_path
+        with (
+            patch.object(tool, "read_file", new_callable=AsyncMock) as mock_read,
+            patch.object(tool, "validate_path"),
+        ):
+            mock_read.return_value = file_content
+
+            result = await tool(command="view", path="/tmp/test.txt", view_range=[3, 5])
+
+            assert isinstance(result, list)
+            assert len(result) > 0
+            # Check that we have text content blocks with the specified range
+            text_blocks = [block for block in result if isinstance(block, TextContent)]
+            assert len(text_blocks) > 0
+            combined_text = "".join(block.text for block in text_blocks)
+            # Lines 3-5 should be in output (using tab format)
+            assert "3\tLine 3" in combined_text
+            assert "4\tLine 4" in combined_text
+            assert "5\tLine 5" in combined_text
+            # Line 1 and 10 should not be in output (outside range)
+            assert "1\tLine 1" not in combined_text
+            assert "10\tLine 10" not in combined_text
+
+    @pytest.mark.asyncio
+    async def test_str_replace_success(self):
+        """Test successful string replacement."""
+        tool = EditTool()
+
+        file_content = "Hello, World!\nThis is a test."
+        expected_content = "Hello, Universe!\nThis is a test."
+
+        # Mock read_file, write_file and validate_path
+        with (
+            patch.object(tool, "read_file", new_callable=AsyncMock) as mock_read,
+            patch.object(tool, "write_file", new_callable=AsyncMock) as mock_write,
+            patch.object(tool, "validate_path"),
+        ):
+            mock_read.return_value = file_content
+
+            result = await tool(
+                command="str_replace", path="/tmp/test.txt", old_str="World", new_str="Universe"
+            )
+
+            assert isinstance(result, list)
+            assert len(result) > 0
+            # Check for success message
+            text_blocks = [block for block in result if isinstance(block, TextContent)]
+            assert len(text_blocks) > 0
+            combined_text = "".join(block.text for block in text_blocks)
+            assert "has been edited" in combined_text
+            mock_write.assert_called_once_with(Path("/tmp/test.txt"), expected_content)
+
+    @pytest.mark.asyncio
+    async def test_str_replace_not_found(self):
+        """Test string replacement when old_str not found."""
+        tool = EditTool()
+
+        file_content = "Hello, World!"
+
+        # Mock read_file and validate_path
+        with (
+            patch.object(tool, "read_file", new_callable=AsyncMock) as mock_read,
+            patch.object(tool, "validate_path"),
+        ):
+            mock_read.return_value = file_content
+
+            with pytest.raises(ToolError) as exc_info:
+                await tool(
+                    command="str_replace",
+                    path="/tmp/test.txt",
+                    old_str="Universe",
+                    new_str="Galaxy",
+                )
+
+            assert "did not appear verbatim" in str(exc_info.value)
+
+    @pytest.mark.asyncio
+    async def test_str_replace_multiple_occurrences(self):
+        """Test string replacement with multiple occurrences."""
+        tool = EditTool()
+
+        file_content = "Test test\nAnother test line"
+
+        # Mock read_file and validate_path
+        with (
+            patch.object(tool, "read_file", new_callable=AsyncMock) as mock_read,
+            patch.object(tool, "validate_path"),
+        ):
+            mock_read.return_value = file_content
+
+            with pytest.raises(ToolError) as exc_info:
+                await tool(
+                    command="str_replace", path="/tmp/test.txt", old_str="test", new_str="example"
+                )
+
+            assert "Multiple occurrences" in str(exc_info.value)
+
+    @pytest.mark.asyncio
+    async def test_invalid_command(self):
+        """Test invalid command raises error."""
+        tool = EditTool()
+
+        # Since EditTool has a bug where it references self.name without defining it,
+        # we'll test by passing a Command that isn't in the literal
+        with tempfile.TemporaryDirectory() as tmpdir:
+            file_path = Path(tmpdir) / "test.txt"
+            # Create the file so validate_path doesn't fail
+            file_path.write_text("test content")
+
+            with pytest.raises((ToolError, AttributeError)) as exc_info:
+                await tool(
+                    command="invalid_command",  # type: ignore
+                    path=str(file_path),
+                )
+
+            # Accept either the expected error or AttributeError from the bug
+            error_msg = str(exc_info.value)
+            assert "Unrecognized command" in error_msg or "name" in error_msg

hud/tools/tests/test_init.py

@@ -1,27 +1,27 @@
-"""Test tools package imports."""
-
-from __future__ import annotations
-
-
-def test_tools_imports():
-    """Test that tools package can be imported."""
-    import hud.tools
-
-    # Check that the module exists
-    assert hud.tools is not None
-
-    # Try importing key submodules
-    from hud.tools import base, bash, edit, utils
-
-    assert base is not None
-    assert bash is not None
-    assert edit is not None
-    assert utils is not None
-
-    # Check key classes/functions
-    assert hasattr(base, "ToolResult")
-    assert hasattr(base, "ToolError")
-    assert hasattr(bash, "BashTool")
-    assert hasattr(edit, "EditTool")
-    assert hasattr(utils, "run")
-    assert hasattr(utils, "maybe_truncate")
+"""Test tools package imports."""
+
+from __future__ import annotations
+
+
+def test_tools_imports():
+    """Test that tools package can be imported."""
+    import hud.tools
+
+    # Check that the module exists
+    assert hud.tools is not None
+
+    # Try importing key submodules
+    from hud.tools import base, bash, edit, utils
+
+    assert base is not None
+    assert bash is not None
+    assert edit is not None
+    assert utils is not None
+
+    # Check key classes/functions
+    assert hasattr(base, "BaseTool")
+    assert hasattr(base, "BaseHub")
+    assert hasattr(bash, "BashTool")
+    assert hasattr(edit, "EditTool")
+    assert hasattr(utils, "run")
+    assert hasattr(utils, "maybe_truncate")