hud-python 0.4.8__py3-none-any.whl → 0.4.9__py3-none-any.whl

hud/cli/remove.py

@@ -0,0 +1,200 @@
+"""Remove HUD environments from local registry."""
+
+from __future__ import annotations
+
+import shutil
+from pathlib import Path
+
+import typer
+import yaml
+
+from hud.utils.design import HUDDesign
+
+from .registry import get_registry_dir, list_registry_entries, load_from_registry
+
+
+def remove_environment(
+    target: str,
+    yes: bool = False,
+    verbose: bool = False,
+) -> None:
+    """Remove an environment from the local registry."""
+    design = HUDDesign()
+    design.header("HUD Environment Removal")
+    
+    # Find the environment to remove
+    found_entry = None
+    found_digest = None
+    
+    # First check if target is a digest
+    for digest, lock_file in list_registry_entries():
+        if digest.startswith(target):
+            found_entry = lock_file
+            found_digest = digest
+            break
+    
+    # If not found by digest, search by name
+    if not found_entry:
+        for digest, lock_file in list_registry_entries():
+            try:
+                lock_data = load_from_registry(digest)
+                if lock_data and "image" in lock_data:
+                    image = lock_data["image"]
+                    # Extract name and tag
+                    name = image.split("@")[0] if "@" in image else image
+                    if "/" in name:
+                        # Match by repo/name or just name
+                        if target in name or name.endswith(f"/{target}"):
+                            found_entry = lock_file
+                            found_digest = digest
+                            break
+            except Exception:
+                continue
+    
+    if not found_entry:
+        design.error(f"Environment not found: {target}")
+        design.info("Use 'hud list' to see available environments")
+        raise typer.Exit(1)
+    
+    # Load and display environment info
+    try:
+        lock_data = load_from_registry(found_digest)
+        if lock_data:
+            image = lock_data.get("image", "unknown")
+            metadata = lock_data.get("metadata", {})
+            description = metadata.get("description", "No description")
+            
+            design.section_title("Environment Details")
+            design.status_item("Image", image)
+            design.status_item("Digest", found_digest)
+            design.status_item("Description", description)
+            design.status_item("Location", str(found_entry.parent))
+    except Exception as e:
+        if verbose:
+            design.warning(f"Could not read environment details: {e}")
+    
+    # Confirm deletion
+    if not yes:
+        design.info("")
+        if not typer.confirm(f"Remove environment {found_digest}?"):
+            design.info("Aborted")
+            raise typer.Exit(0)
+    
+    # Remove the environment directory
+    try:
+        env_dir = found_entry.parent
+        shutil.rmtree(env_dir)
+        design.success(f"Removed environment: {found_digest}")
+        
+        # Check if the image is still available locally
+        if lock_data:
+            image = lock_data.get("image", "")
+            if image:
+                design.info("")
+                design.info("Note: The Docker image may still exist locally.")
+                design.info(f"To remove it, run: [cyan]docker rmi {image.split('@')[0]}[/cyan]")
+    except Exception as e:
+        design.error(f"Failed to remove environment: {e}")
+        raise typer.Exit(1)
+
+
+def remove_all_environments(
+    yes: bool = False,
+    verbose: bool = False,
+) -> None:
+    """Remove all environments from the local registry."""
+    design = HUDDesign()
+    design.header("Remove All HUD Environments")
+    
+    registry_dir = get_registry_dir()
+    if not registry_dir.exists():
+        design.info("No environments found in local registry.")
+        return
+    
+    # Count environments
+    entries = list(list_registry_entries())
+    if not entries:
+        design.info("No environments found in local registry.")
+        return
+    
+    design.warning(f"This will remove {len(entries)} environment(s) from the local registry!")
+    
+    # List environments that will be removed
+    design.section_title("Environments to Remove")
+    for digest, lock_file in entries:
+        try:
+            lock_data = load_from_registry(digest)
+            if lock_data:
+                image = lock_data.get("image", "unknown")
+                design.info(f"  • {digest[:12]} - {image}")
+        except Exception:
+            design.info(f"  • {digest[:12]}")
+    
+    # Confirm deletion
+    if not yes:
+        design.info("")
+        if not typer.confirm("Remove ALL environments?", default=False):
+            design.info("Aborted")
+            raise typer.Exit(0)
+    
+    # Remove all environments
+    removed = 0
+    failed = 0
+    
+    for digest, lock_file in entries:
+        try:
+            env_dir = lock_file.parent
+            shutil.rmtree(env_dir)
+            removed += 1
+            if verbose:
+                design.success(f"Removed: {digest}")
+        except Exception as e:
+            failed += 1
+            if verbose:
+                design.error(f"Failed to remove {digest}: {e}")
+    
+    design.info("")
+    if failed == 0:
+        design.success(f"Successfully removed {removed} environment(s)")
+    else:
+        design.warning(f"Removed {removed} environment(s), failed to remove {failed}")
+    
+    design.info("")
+    design.info("Note: Docker images may still exist locally.")
+    design.info("To remove them, use: [cyan]docker image prune[/cyan]")
+
+
+def remove_command(
+    target: str | None = typer.Argument(
+        None, 
+        help="Environment to remove (digest, name, or 'all' for all environments)"
+    ),
+    yes: bool = typer.Option(
+        False, "--yes", "-y", help="Skip confirmation prompt"
+    ),
+    verbose: bool = typer.Option(
+        False, "--verbose", "-v", help="Show detailed output"
+    ),
+) -> None:
+    """🗑️ Remove HUD environments from local registry.
+    
+    Removes environment metadata from ~/.hud/envs/
+    Note: This does not remove the Docker images.
+    
+    Examples:
+        hud remove abc123              # Remove by digest
+        hud remove text_2048           # Remove by name
+        hud remove hudpython/test_init # Remove by full name
+        hud remove all                 # Remove all environments
+        hud remove all --yes           # Remove all without confirmation
+    """
+    if not target:
+        design = HUDDesign()
+        design.error("Please specify an environment to remove or 'all'")
+        design.info("Use 'hud list' to see available environments")
+        raise typer.Exit(1)
+    
+    if target.lower() == "all":
+        remove_all_environments(yes, verbose)
+    else:
+        remove_environment(target, yes, verbose)

hud/cli/tests/test_analyze_metadata.py

@@ -0,0 +1,277 @@
+"""Tests for analyze_metadata.py - Fast metadata analysis functions."""
+
+from __future__ import annotations
+
+import json
+import os
+import tempfile
+from pathlib import Path
+from unittest import mock
+
+import pytest
+import yaml
+
+from hud.cli.analyze_metadata import (
+    analyze_from_metadata,
+    check_local_cache,
+    fetch_lock_from_registry,
+)
+from hud.cli.registry import save_to_registry
+
+
+@pytest.fixture
+def mock_registry_dir(tmp_path):
+    """Create a mock registry directory."""
+    registry_dir = tmp_path / ".hud" / "envs"
+    registry_dir.mkdir(parents=True)
+    return registry_dir
+
+
+@pytest.fixture
+def sample_lock_data():
+    """Sample lock data for testing."""
+    return {
+        "image": "test/environment:latest",
+        "digest": "sha256:abc123",
+        "build": {
+            "timestamp": 1234567890,
+            "version": "1.0.0",
+            "hud_version": "0.1.0",
+        },
+        "environment": {
+            "initializeMs": 1500,
+            "toolCount": 5,
+            "variables": {"API_KEY": "required"},
+        },
+        "tools": [
+            {
+                "name": "test_tool",
+                "description": "A test tool",
+                "inputSchema": {
+                    "type": "object",
+                    "properties": {"message": {"type": "string"}},
+                },
+            }
+        ],
+        "resources": [
+            {
+                "uri": "test://resource",
+                "name": "Test Resource",
+                "description": "A test resource",
+                "mimeType": "text/plain",
+            }
+        ],
+        "prompts": [
+            {
+                "name": "test_prompt",
+                "description": "A test prompt",
+                "arguments": [{"name": "arg1", "description": "First argument"}],
+            }
+        ],
+    }
+
+
+class TestFetchLockFromRegistry:
+    """Test fetching lock data from registry."""
+
+    @mock.patch("requests.get")
+    def test_fetch_lock_success(self, mock_get):
+        """Test successful fetch from registry."""
+        mock_response = mock.Mock()
+        mock_response.status_code = 200
+        mock_response.json.return_value = {
+            "lock": yaml.dump({"test": "data"})
+        }
+        mock_get.return_value = mock_response
+
+        result = fetch_lock_from_registry("test/env:latest")
+        assert result == {"test": "data"}
+        mock_get.assert_called_once()
+
+    @mock.patch("requests.get")
+    def test_fetch_lock_with_lock_data(self, mock_get):
+        """Test fetch when response has lock_data key."""
+        mock_response = mock.Mock()
+        mock_response.status_code = 200
+        mock_response.json.return_value = {
+            "lock_data": {"test": "data"}
+        }
+        mock_get.return_value = mock_response
+
+        result = fetch_lock_from_registry("test/env:latest")
+        assert result == {"test": "data"}
+
+    @mock.patch("requests.get")
+    def test_fetch_lock_direct_data(self, mock_get):
+        """Test fetch when response is direct lock data."""
+        mock_response = mock.Mock()
+        mock_response.status_code = 200
+        mock_response.json.return_value = {"test": "data"}
+        mock_get.return_value = mock_response
+
+        result = fetch_lock_from_registry("test/env:latest")
+        assert result == {"test": "data"}
+
+    @mock.patch("requests.get")
+    def test_fetch_lock_adds_latest_tag(self, mock_get):
+        """Test that :latest tag is added if missing."""
+        mock_response = mock.Mock()
+        mock_response.status_code = 404
+        mock_get.return_value = mock_response
+
+        fetch_lock_from_registry("test/env")
+        
+        # Check that the URL includes :latest
+        call_args = mock_get.call_args
+        assert "test/env:latest" in call_args[0][0]
+
+    @mock.patch("requests.get")
+    def test_fetch_lock_failure(self, mock_get):
+        """Test fetch failure returns None."""
+        mock_response = mock.Mock()
+        mock_response.status_code = 404
+        mock_get.return_value = mock_response
+
+        result = fetch_lock_from_registry("test/env:latest")
+        assert result is None
+
+    @mock.patch("requests.get")
+    def test_fetch_lock_exception(self, mock_get):
+        """Test fetch exception returns None."""
+        mock_get.side_effect = Exception("Network error")
+
+        result = fetch_lock_from_registry("test/env:latest")
+        assert result is None
+
+
+class TestCheckLocalCache:
+    """Test checking local cache for lock data."""
+
+    def test_check_local_cache_found(self, mock_registry_dir, sample_lock_data, monkeypatch):
+        """Test finding lock data in local cache."""
+        # Mock registry directory
+        monkeypatch.setattr("hud.cli.registry.get_registry_dir", lambda: mock_registry_dir)
+        
+        # Save sample data to registry
+        save_to_registry(sample_lock_data, "test/environment:latest", verbose=False)
+        
+        # Check cache
+        result = check_local_cache("test/environment:latest")
+        assert result is not None
+        assert result["image"] == "test/environment:latest"
+
+    def test_check_local_cache_not_found(self, mock_registry_dir, monkeypatch):
+        """Test when lock data not in local cache."""
+        monkeypatch.setattr("hud.cli.registry.get_registry_dir", lambda: mock_registry_dir)
+        
+        result = check_local_cache("nonexistent/env:latest")
+        assert result is None
+
+    def test_check_local_cache_invalid_yaml(self, mock_registry_dir, monkeypatch):
+        """Test when lock file has invalid YAML."""
+        monkeypatch.setattr("hud.cli.registry.get_registry_dir", lambda: mock_registry_dir)
+        
+        # Create invalid lock file
+        digest = "sha256:invalid"
+        lock_file = mock_registry_dir / digest / "hud.lock.yaml"
+        lock_file.parent.mkdir(parents=True)
+        lock_file.write_text("invalid: yaml: content:")
+        
+        result = check_local_cache("test/invalid:latest")
+        assert result is None
+
+
+# Note: TestFormatAnalysisOutput class removed since format_analysis_output function doesn't exist
+# The formatting is done inline within analyze_from_metadata
+
+
+@pytest.mark.asyncio
+class TestAnalyzeFromMetadata:
+    """Test the main analyze_from_metadata function."""
+
+    @mock.patch("hud.cli.analyze_metadata.check_local_cache")
+    @mock.patch("hud.cli.analyze_metadata.console")
+    async def test_analyze_from_local_cache(self, mock_console, mock_check, sample_lock_data):
+        """Test analyzing from local cache."""
+        mock_check.return_value = sample_lock_data
+        
+        await analyze_from_metadata("test/env:latest", "json", verbose=False)
+        
+        mock_check.assert_called_once_with("test/env:latest")
+        # Should output JSON
+        mock_console.print_json.assert_called_once()
+
+    @mock.patch("hud.cli.analyze_metadata.check_local_cache")
+    @mock.patch("hud.cli.analyze_metadata.fetch_lock_from_registry")
+    @mock.patch("hud.cli.analyze_metadata.save_to_registry")
+    @mock.patch("hud.cli.analyze_metadata.console")
+    async def test_analyze_from_registry(
+        self, mock_console, mock_save, mock_fetch, mock_check, sample_lock_data
+    ):
+        """Test analyzing from registry when not in cache."""
+        mock_check.return_value = None
+        mock_fetch.return_value = sample_lock_data
+        
+        await analyze_from_metadata("test/env:latest", "json", verbose=False)
+        
+        mock_check.assert_called_once()
+        mock_fetch.assert_called_once()
+        mock_save.assert_called_once()  # Should save to cache
+        mock_console.print_json.assert_called_once()
+
+    @mock.patch("hud.cli.analyze_metadata.check_local_cache")
+    @mock.patch("hud.cli.analyze_metadata.fetch_lock_from_registry")
+    @mock.patch("hud.cli.analyze_metadata.design")
+    @mock.patch("hud.cli.analyze_metadata.console")
+    async def test_analyze_not_found(self, mock_console, mock_design, mock_fetch, mock_check):
+        """Test when environment not found anywhere."""
+        mock_check.return_value = None
+        mock_fetch.return_value = None
+        
+        await analyze_from_metadata("test/notfound:latest", "json", verbose=False)
+        
+        # Should show error
+        mock_design.error.assert_called_with("Environment metadata not found")
+        # Should print suggestions
+        mock_console.print.assert_called()
+
+    @mock.patch("hud.cli.analyze_metadata.check_local_cache")
+    @mock.patch("hud.cli.analyze_metadata.console")
+    async def test_analyze_verbose_mode(self, mock_console, mock_check, sample_lock_data):
+        """Test verbose mode includes input schemas."""
+        mock_check.return_value = sample_lock_data
+        
+        await analyze_from_metadata("test/env:latest", "json", verbose=True)
+        
+        # In verbose mode, the JSON output should include input schemas
+        mock_console.print_json.assert_called_once()
+        # Get the JSON string that was printed
+        call_args = mock_console.print_json.call_args[0][0]
+        output_data = json.loads(call_args)
+        assert "inputSchema" in output_data["tools"][0]
+
+    @mock.patch("hud.cli.analyze_metadata.check_local_cache")
+    @mock.patch("hud.cli.analyze_metadata.fetch_lock_from_registry")
+    async def test_analyze_registry_reference_parsing(self, mock_fetch, mock_check):
+        """Test parsing of different registry reference formats."""
+        mock_check.return_value = None
+        mock_fetch.return_value = {"test": "data"}
+        
+        # Test different reference formats
+        test_cases = [
+            ("docker.io/org/name:tag", "org/name:tag"),
+            ("registry-1.docker.io/org/name", "org/name"),
+            ("org/name@sha256:abc", "org/name"),
+            ("org/name", "org/name"),
+            ("name:tag", "name:tag"),
+        ]
+        
+        for input_ref, expected_call in test_cases:
+            await analyze_from_metadata(input_ref, "json", verbose=False)
+            
+            # Check what was passed to fetch_lock_from_registry
+            calls = mock_fetch.call_args_list
+            last_call = calls[-1][0][0]
+            
+            # The function might add :latest, so check base name
+            assert expected_call.split(":")[0] in last_call