hud-python 0.4.10__py3-none-any.whl → 0.4.12__py3-none-any.whl

hud/cli/tests/test_registry.py

@@ -5,10 +5,9 @@ from __future__ import annotations
 from pathlib import Path
 from unittest import mock
 
-import pytest
 import yaml
 
-from hud.cli.registry import (
+from hud.cli.utils.registry import (
     extract_digest_from_image,
     extract_name_and_tag,
     get_registry_dir,
@@ -25,7 +24,7 @@ class TestGetRegistryDir:
         """Test default registry directory."""
         with mock.patch("pathlib.Path.home") as mock_home:
             mock_home.return_value = Path("/home/user")
-            
+
             registry_dir = get_registry_dir()
             assert registry_dir == Path("/home/user/.hud/envs")
 
@@ -119,65 +118,64 @@ class TestExtractNameAndTag:
 class TestSaveToRegistry:
     """Test saving to local registry."""
 
-    @mock.patch("hud.cli.registry.HUDDesign")
+    @mock.patch("hud.cli.utils.registry.HUDDesign")
     def test_save_success(self, mock_design_class, tmp_path):
         """Test successful save to registry."""
         mock_design = mock.Mock()
         mock_design_class.return_value = mock_design
-        
+
         # Mock home directory
         with mock.patch("pathlib.Path.home", return_value=tmp_path):
-            lock_data = {
-                "image": "test:latest@sha256:abc123",
-                "tools": ["tool1", "tool2"]
-            }
-            
+            lock_data = {"image": "test:latest@sha256:abc123", "tools": ["tool1", "tool2"]}
+
             result = save_to_registry(lock_data, "test:latest@sha256:abc123def456789")
-            
+
             assert result is not None
             assert result.exists()
             assert result.name == "hud.lock.yaml"
-            
+
             # Verify content
             with open(result) as f:
                 saved_data = yaml.safe_load(f)
             assert saved_data == lock_data
-            
+
             # Verify directory structure
             assert result.parent.name == "abc123def456"
-            
+
             mock_design.success.assert_called_once()
 
-    @mock.patch("hud.cli.registry.HUDDesign")
+    @mock.patch("hud.cli.utils.registry.HUDDesign")
     def test_save_verbose(self, mock_design_class, tmp_path):
         """Test save with verbose output."""
         mock_design = mock.Mock()
         mock_design_class.return_value = mock_design
-        
+
         with mock.patch("pathlib.Path.home", return_value=tmp_path):
             lock_data = {"image": "test:v1"}
-            
+
             result = save_to_registry(lock_data, "test:v1", verbose=True)
-            
+
             assert result is not None
             # Should show verbose info
             assert mock_design.info.call_count >= 1
 
-    @mock.patch("hud.cli.registry.HUDDesign")
+    @mock.patch("hud.cli.utils.registry.HUDDesign")
     def test_save_failure(self, mock_design_class):
         """Test handling save failure."""
         mock_design = mock.Mock()
         mock_design_class.return_value = mock_design
-        
+
         # Mock file operations to fail
-        with mock.patch("builtins.open", side_effect=IOError("Permission denied")):
-            with mock.patch("pathlib.Path.home", return_value=Path("/tmp")):
-                lock_data = {"image": "test:latest"}
-                
-                result = save_to_registry(lock_data, "test:latest", verbose=True)
-                
-                assert result is None
-                mock_design.warning.assert_called_once()
+        with (
+            mock.patch("builtins.open", side_effect=OSError("Permission denied")),
+            mock.patch("pathlib.Path.home", return_value=Path("/tmp")),
+        ):
+            lock_data = {"image": "test:latest"}
+
+            result = save_to_registry(lock_data, "test:latest", verbose=True)
+
+            assert result is None
+            mock_design.warning.assert_called_once()
 
 
 class TestLoadFromRegistry:
@@ -190,11 +188,11 @@ class TestLoadFromRegistry:
             registry_dir = get_registry_dir()
             digest_dir = registry_dir / "abc123"
             digest_dir.mkdir(parents=True)
-            
+
             lock_data = {"image": "test:latest", "version": "1.0"}
             lock_file = digest_dir / "hud.lock.yaml"
             lock_file.write_text(yaml.dump(lock_data))
-            
+
             # Load it back
             loaded = load_from_registry("abc123")
             assert loaded == lock_data
@@ -211,10 +209,10 @@ class TestLoadFromRegistry:
             registry_dir = get_registry_dir()
             digest_dir = registry_dir / "bad"
             digest_dir.mkdir(parents=True)
-            
+
             lock_file = digest_dir / "hud.lock.yaml"
             lock_file.write_text("invalid: yaml: content:")
-            
+
             loaded = load_from_registry("bad")
             assert loaded is None
 
@@ -232,26 +230,26 @@ class TestListRegistryEntries:
         """Test listing multiple entries."""
         with mock.patch("pathlib.Path.home", return_value=tmp_path):
             registry_dir = get_registry_dir()
-            
+
             # Create several entries
             for digest in ["abc123", "def456", "ghi789"]:
                 digest_dir = registry_dir / digest
                 digest_dir.mkdir(parents=True)
                 lock_file = digest_dir / "hud.lock.yaml"
                 lock_file.write_text(f"image: test:{digest}")
-            
+
             # Create a directory without lock file (should be ignored)
             (registry_dir / "nolockfile").mkdir(parents=True)
-            
+
             # Create a file in registry dir (should be ignored)
             (registry_dir / "README.txt").write_text("info")
-            
+
             entries = list_registry_entries()
-            
+
             assert len(entries) == 3
             digests = [entry[0] for entry in entries]
             assert set(digests) == {"abc123", "def456", "ghi789"}
-            
+
             # Verify all paths are lock files
             for _, lock_path in entries:
                 assert lock_path.name == "hud.lock.yaml"

hud/cli/tests/test_utils.py

@@ -7,7 +7,7 @@ from unittest.mock import patch
 
 import pytest
 
-from hud.cli.utils import HINT_REGISTRY, CaptureLogger, Colors, analyze_error_for_hints
+from hud.cli.utils.logging import HINT_REGISTRY, CaptureLogger, Colors, analyze_error_for_hints
 
 
 class TestColors:

hud/cli/utils/__init__.py

@@ -0,0 +1 @@
+"""Utility modules for HUD CLI."""

hud/cli/{docker_utils.py → utils/docker.py}

@@ -81,3 +81,39 @@ def image_exists(image_name: str) -> bool:
         stderr=subprocess.DEVNULL,
     )
     return result.returncode == 0
+
+
+def remove_container(container_name: str) -> bool:
+    """Remove a Docker container by name.
+
+    Args:
+        container_name: Name of the container to remove
+
+    Returns:
+        True if successful or container doesn't exist, False on error
+    """
+    try:
+        subprocess.run(  # noqa: S603
+            ["docker", "rm", "-f", container_name],  # noqa: S607
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+            check=False,  # Don't raise error if container doesn't exist
+        )
+        return True
+    except Exception:
+        return False
+
+
+def generate_container_name(identifier: str, prefix: str = "hud") -> str:
+    """Generate a safe container name from an identifier.
+
+    Args:
+        identifier: Image name or other identifier
+        prefix: Prefix for the container name
+
+    Returns:
+        Safe container name with special characters replaced
+    """
+    # Replace special characters with hyphens
+    safe_name = identifier.replace(":", "-").replace("/", "-").replace("\\", "-")
+    return f"{prefix}-{safe_name}"

hud/cli/{env_utils.py → utils/environment.py}

@@ -4,7 +4,6 @@ from __future__ import annotations
 
 import subprocess
 from pathlib import Path
-from typing import Any
 
 import toml
 
@@ -32,7 +31,7 @@ def get_image_name(directory: str | Path, image_override: str | None = None) ->
             if config.get("tool", {}).get("hud", {}).get("image"):
                 return config["tool"]["hud"]["image"], "cache"
         except Exception:
-            pass  # Silent failure, will use auto-generated name
+            design.error("Error loading pyproject.toml")
 
     # Auto-generate with :dev tag
     dir_path = Path(directory).resolve()  # Get absolute path first
@@ -74,7 +73,7 @@ def update_pyproject_toml(directory: str | Path, image_name: str, silent: bool =
 
 def build_environment(directory: str | Path, image_name: str, no_cache: bool = False) -> bool:
     """Build Docker image for an environment.
-    
+
     Returns:
         True if build succeeded, False otherwise
     """
@@ -112,7 +111,7 @@ def image_exists(image_name: str) -> bool:
 
 def is_environment_directory(path: str | Path) -> bool:
     """Check if a path looks like an environment directory.
-    
+
     An environment directory should have:
     - A Dockerfile
     - A pyproject.toml file
@@ -121,13 +120,14 @@ def is_environment_directory(path: str | Path) -> bool:
     dir_path = Path(path)
     if not dir_path.is_dir():
         return False
-    
+
     # Must have Dockerfile
     if not (dir_path / "Dockerfile").exists():
         return False
-        
+
     # Must have pyproject.toml
     if not (dir_path / "pyproject.toml").exists():
+        design.error("pyproject.toml not found")
         return False
-        
+
     return True

hud/cli/{interactive.py → utils/interactive.py}

@@ -112,52 +112,103 @@ class InteractiveMCPTester:
         choices = []
         tool_map = {}
 
-        for _, tool in enumerate(self.tools):
-            # Create display name
+        # Group tools by hub for better organization
+        hub_groups = {}
+        regular_tools = []
+
+        for tool in self.tools:
             if "/" in tool.name:
                 hub, name = tool.name.split("/", 1)
-                display = f"[{hub}] {name}"
+                if hub not in hub_groups:
+                    hub_groups[hub] = []
+                hub_groups[hub].append((name, tool))
             else:
-                display = tool.name
+                regular_tools.append(tool)
+
+        # Add regular tools first
+        if regular_tools:
+            # Add a separator for regular tools section
+            if len(hub_groups) > 0:
+                choices.append("───── Regular Tools ─────")
+
+            for tool in regular_tools:
+                # Format: Bold tool name with color + dim description
+                if tool.description:
+                    display = f"• {tool.name} │ {tool.description}"
+                else:
+                    display = f"• {tool.name}"
+
+                choices.append(display)
+                tool_map[display] = tool
 
-            # Add description if available
-            if tool.description:
-                display += f" - {tool.description}"
+        # Add hub-grouped tools with visual separation
+        for hub_name, tools in sorted(hub_groups.items()):
+            # Add a visual separator for each hub
+            choices.append(f"───── {hub_name} ─────")
 
-            choices.append(display)
-            tool_map[display] = tool
+            for name, tool in sorted(tools, key=lambda x: x[0]):
+                # Format with hub indicator and better separation
+                if tool.description:
+                    # Remove redundant description text
+                    desc = tool.description
+                    # Truncate long descriptions
+                    if len(desc) > 60:
+                        desc = desc[:57] + "..."
+                    display = f"• {name} │ {desc}"
+                else:
+                    display = f"• {name}"
+
+                choices.append(display)
+                tool_map[display] = tool
 
-        # Add quit option
+        # Add quit option with spacing
+        choices.append("─────────────────────")
         choices.append("❌ Quit")
 
         # Show selection menu with arrow keys
         console.print("\n[cyan]Select a tool (use arrow keys):[/cyan]")
 
         try:
-            # Use questionary's async select with custom styling
+            # Create custom Choice objects for better formatting
+            from questionary import Choice
+
+            formatted_choices = []
+            for choice in choices:
+                if choice.startswith("─────"):
+                    # Separator - make it unselectable and styled
+                    formatted_choices.append(Choice(title=choice, disabled=True, shortcut_key=None))  # type: ignore[arg-type]
+                elif choice == "❌ Quit":
+                    formatted_choices.append(choice)
+                else:
+                    formatted_choices.append(choice)
+
+            # Use questionary's async select with enhanced styling
             selected = await questionary.select(
                 "",
-                choices=choices,
+                choices=formatted_choices,
                 style=questionary.Style(
                     [
                         ("question", ""),
-                        ("pointer", "fg:#ff9d00 bold"),
-                        ("highlighted", "fg:#ff9d00 bold"),
-                        ("selected", "fg:#cc5454"),
-                        ("separator", "fg:#6c6c6c"),
-                        ("instruction", "fg:#858585 italic"),
+                        ("pointer", "fg:#ff9d00 bold"),  # Orange pointer
+                        ("highlighted", "fg:#00d7ff bold"),  # Bright cyan for highlighted
+                        ("selected", "fg:#00ff00 bold"),  # Green for selected
+                        ("separator", "fg:#666666"),  # Gray for separators
+                        ("instruction", "fg:#858585 italic"),  # Dim instructions
+                        ("disabled", "fg:#666666"),  # Gray for disabled items
+                        ("text", "fg:#ffffff"),  # White text
                     ]
                 ),
+                instruction="(Use ↑/↓ arrows, Enter to select, Esc to cancel)",
             ).unsafe_ask_async()
 
             if selected is None:
                 console.print("[yellow]No selection made (ESC or Ctrl+C pressed)[/yellow]")
                 return None
 
-            if selected == "❌ Quit":
+            if selected == "❌ Quit" or selected.startswith("─────"):
                 return None
 
-            return tool_map[selected]
+            return tool_map.get(selected)
 
         except KeyboardInterrupt:
             console.print("[yellow]Interrupted by user[/yellow]")
@@ -236,6 +287,27 @@ class InteractiveMCPTester:
                     if not value_str and not is_required:
                         continue
                     value = [v.strip() for v in value_str.split(",")]
+                elif prop_type == "object":
+                    # For object types, allow JSON input
+                    console.print(f"[dim]Enter JSON object for {prop_name}:[/dim]")
+                    value_str = await questionary.text(
+                        prompt + " (JSON format)", default="{}"
+                    ).unsafe_ask_async()
+                    if not value_str and not is_required:
+                        continue
+                    try:
+                        value = json.loads(value_str)
+                    except json.JSONDecodeError as e:
+                        console.print(f"[red]Invalid JSON: {e}[/red]")
+                        # Try again
+                        value_str = await questionary.text(
+                            prompt + " (JSON format, please fix the error)", default=value_str
+                        ).unsafe_ask_async()
+                        try:
+                            value = json.loads(value_str)
+                        except json.JSONDecodeError:
+                            console.print("[red]Still invalid JSON, using empty object[/red]")
+                            value = {}
                 else:  # string or unknown
                     value = await questionary.text(prompt, default="").unsafe_ask_async()
                     if not value and not is_required:

hud/cli/{analyze_metadata.py → utils/metadata.py}

@@ -2,7 +2,6 @@
 
 from __future__ import annotations
 
-from pathlib import Path
 from urllib.parse import quote
 
 import requests
@@ -13,7 +12,11 @@ from rich.progress import Progress, SpinnerColumn, TextColumn
 from hud.settings import settings
 from hud.utils.design import HUDDesign
 
-from .registry import get_registry_dir, list_registry_entries, extract_digest_from_image, load_from_registry
+from .registry import (
+    extract_digest_from_image,
+    list_registry_entries,
+    load_from_registry,
+)
 
 console = Console()
 design = HUDDesign()
@@ -60,13 +63,13 @@ def check_local_cache(reference: str) -> dict | None:
     lock_data = load_from_registry(digest)
     if lock_data:
         return lock_data
-    
+
     # If not found and reference has a name, search by name pattern
     if "/" in reference:
         # Look for any cached version of this image
         ref_base = reference.split("@")[0].split(":")[0]
-        
-        for digest, lock_file in list_registry_entries():
+
+        for _, lock_file in list_registry_entries():
             try:
                 with open(lock_file) as f:
                     lock_data = yaml.safe_load(f)
@@ -78,8 +81,8 @@ def check_local_cache(reference: str) -> dict | None:
                     if ref_base in img_base or img_base in ref_base:
                         return lock_data
             except Exception:
-                continue
-    
+                design.error("Error loading lock file")
+
     return None
 
 
@@ -87,7 +90,7 @@ async def analyze_from_metadata(reference: str, output_format: str, verbose: boo
     """Analyze environment from cached or registry metadata."""
     import json
 
-    from .analyze import display_interactive, display_markdown
+    from hud.cli.analyze import display_interactive, display_markdown
 
     design.header("MCP Environment Analysis", icon="🔍")
     design.info(f"Looking up: {reference}")
@@ -146,6 +149,7 @@ async def analyze_from_metadata(reference: str, output_format: str, verbose: boo
 
                 # Save to local cache for next time
                 from .registry import save_to_registry
+
                 save_to_registry(lock_data, lock_data.get("image", ""), verbose=False)
             else:
                 progress.update(task, description="[red]✗ Not found[/red]")

hud/cli/{registry.py → utils/registry.py}

@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 from pathlib import Path
-from typing import Dict, Optional, Any
+from typing import Any
 
 import yaml
 
@@ -17,10 +17,10 @@ def get_registry_dir() -> Path:
 
 def extract_digest_from_image(image_ref: str) -> str:
     """Extract a digest identifier from a Docker image reference.
-    
+
     Args:
         image_ref: Docker image reference (e.g., "image:tag@sha256:abc123...")
-        
+
     Returns:
         Digest string for use as directory name (max 12 chars)
     """
@@ -41,13 +41,13 @@ def extract_digest_from_image(image_ref: str) -> str:
 
 def extract_name_and_tag(image_ref: str) -> tuple[str, str]:
     """Extract organization/name and tag from Docker image reference.
-    
+
     Args:
         image_ref: Docker image reference
-        
+
     Returns:
         Tuple of (name, tag) where name includes org/repo
-        
+
     Examples:
         docker.io/hudpython/test_init:latest@sha256:... -> (hudpython/test_init, latest)
         hudpython/myenv:v1.0 -> (hudpython/myenv, v1.0)
@@ -56,54 +56,52 @@ def extract_name_and_tag(image_ref: str) -> tuple[str, str]:
     # Remove digest if present
     if "@" in image_ref:
         image_ref = image_ref.split("@")[0]
-    
+
     # Remove registry prefix if present
     if image_ref.startswith(("docker.io/", "registry-1.docker.io/", "index.docker.io/")):
         image_ref = "/".join(image_ref.split("/")[1:])
-    
+
     # Extract tag
     if ":" in image_ref:
         name, tag = image_ref.rsplit(":", 1)
     else:
         name = image_ref
         tag = "latest"
-    
+
     return name, tag
 
 
 def save_to_registry(
-    lock_data: Dict[str, Any], 
-    image_ref: str,
-    verbose: bool = False
-) -> Optional[Path]:
+    lock_data: dict[str, Any], image_ref: str, verbose: bool = False
+) -> Path | None:
     """Save environment lock data to the local registry.
-    
+
     Args:
         lock_data: The lock file data to save
         image_ref: Docker image reference for digest extraction
         verbose: Whether to show verbose output
-        
+
     Returns:
         Path to the saved lock file, or None if save failed
     """
     design = HUDDesign()
-    
+
     try:
         # Extract digest for registry storage
         digest = extract_digest_from_image(image_ref)
-        
+
         # Store under ~/.hud/envs/<digest>/
         local_env_dir = get_registry_dir() / digest
         local_env_dir.mkdir(parents=True, exist_ok=True)
-        
+
         local_lock_path = local_env_dir / "hud.lock.yaml"
         with open(local_lock_path, "w") as f:
             yaml.dump(lock_data, f, default_flow_style=False, sort_keys=False)
-        
+
         design.success(f"Added to local registry: {digest}")
         if verbose:
             design.info(f"Registry location: {local_lock_path}")
-            
+
         return local_lock_path
     except Exception as e:
         if verbose:
@@ -111,20 +109,20 @@ def save_to_registry(
         return None
 
 
-def load_from_registry(digest: str) -> Optional[Dict[str, Any]]:
+def load_from_registry(digest: str) -> dict[str, Any] | None:
     """Load environment lock data from the local registry.
-    
+
     Args:
         digest: The digest/identifier of the environment
-        
+
     Returns:
         Lock data dictionary, or None if not found
     """
     lock_path = get_registry_dir() / digest / "hud.lock.yaml"
-    
+
     if not lock_path.exists():
         return None
-        
+
     try:
         with open(lock_path) as f:
             return yaml.safe_load(f)
@@ -134,22 +132,22 @@ def load_from_registry(digest: str) -> Optional[Dict[str, Any]]:
 
 def list_registry_entries() -> list[tuple[str, Path]]:
     """List all entries in the local registry.
-    
+
     Returns:
         List of (digest, lock_path) tuples
     """
     registry_dir = get_registry_dir()
-    
+
     if not registry_dir.exists():
         return []
-        
+
     entries = []
     for digest_dir in registry_dir.iterdir():
         if not digest_dir.is_dir():
             continue
-            
+
         lock_file = digest_dir / "hud.lock.yaml"
         if lock_file.exists():
             entries.append((digest_dir.name, lock_file))
-            
+
     return entries

hud/cli/{remote_runner.py → utils/remote_runner.py}

@@ -199,7 +199,7 @@ async def run_remote_http(
     verbose: bool = False,
 ) -> None:
     """Run remote MCP server with HTTP transport."""
-    from .utils import find_free_port
+    from .logging import find_free_port
 
     # Find available port
     actual_port = find_free_port(port)