hud-python 0.4.45__py3-none-any.whl → 0.5.13__py3-none-any.whl

hud/cli/rft_status.py

@@ -0,0 +1,145 @@
+from __future__ import annotations
+
+import logging
+
+import httpx
+import typer
+from rich.console import Console
+
+from hud.cli.utils.viewer import show_json_interactive
+from hud.settings import settings
+from hud.utils.hud_console import HUDConsole
+
+logger = logging.getLogger(__name__)
+console = Console()
+hud_console = HUDConsole()
+
+
+def rft_status_command(
+    model_id: str,
+    verbose: bool = False,
+) -> None:
+    """
+    Check the status of an RFT training job.
+    """
+    # hud_console.header("RFT Job Status")
+
+    # Preflight check: API key
+    if not settings.api_key:
+        hud_console.error("HUD_API_KEY not found in environment.")
+        hud_console.info("Run 'hud set HUD_API_KEY=...' or export it.")
+        raise typer.Exit(1)
+
+    # Prepare request
+    base_url = settings.hud_rl_url
+    url = f"{base_url}/training/jobs/{model_id}/raw-status"
+
+    headers = {"Authorization": f"Bearer {settings.api_key}"}
+
+    hud_console.info(f"Fetching status for model: {model_id}")
+
+    try:
+        with httpx.Client(timeout=30.0) as client:
+            resp = client.get(url, headers=headers)
+
+            if resp.status_code >= 400:
+                try:
+                    detail = resp.json()
+                except Exception as e:
+                    detail = f"{resp.text} - {e}"
+                hud_console.error(f"Request failed ({resp.status_code}): {detail}")
+                raise typer.Exit(1)
+
+            data = resp.json()
+
+            # Display status information
+            status = data.get("status", "Unknown")
+
+            # Show status with appropriate styling
+            if status.lower() in ["succeeded", "completed"]:
+                hud_console.success(f"Job Status: {status}")
+            elif status.lower() in ["failed", "error", "cancelled"]:
+                hud_console.error(f"Job Status: {status}")
+            elif status.lower() in [
+                "running",
+                "in_progress",
+                "processing",
+                "validating_files",
+                "queued",
+            ]:
+                hud_console.info(f"Job Status: {status} 🔄")
+            else:
+                hud_console.info(f"Job Status: {status}")
+
+            # Most important: Show fine-tuned model if available
+            if data.get("fine_tuned_model"):
+                hud_console.success(f"Fine-tuned Model: {data['fine_tuned_model']}")
+                console.print("\n[dim]You can now use this model in your applications![/dim]")
+
+            # Display full response in verbose mode or interactive viewer
+            if verbose:
+                hud_console.section_title("Full Status Details")
+                show_json_interactive(data, title="RFT Job Status", initial_expanded=True)
+            else:
+                # Show key information
+                if "model" in data:
+                    hud_console.info(f"Base Model: {data['model']}")
+
+                if "created_at" in data:
+                    # Convert timestamp to readable format if it's a unix timestamp
+                    created = data["created_at"]
+                    if isinstance(created, int) and created > 1000000000:
+                        from datetime import datetime
+
+                        created_str = datetime.fromtimestamp(created).strftime("%Y-%m-%d %H:%M:%S")
+                        hud_console.info(f"Created: {created_str}")
+                    else:
+                        hud_console.info(f"Created: {created}")
+
+                if data.get("finished_at"):
+                    finished = data["finished_at"]
+                    if isinstance(finished, int) and finished > 1000000000:
+                        from datetime import datetime
+
+                        finished_str = datetime.fromtimestamp(finished).strftime(
+                            "%Y-%m-%d %H:%M:%S"
+                        )
+                        hud_console.info(f"Finished: {finished_str}")
+                    else:
+                        hud_console.info(f"Finished: {finished}")
+
+                if data.get("trained_tokens"):
+                    hud_console.info(f"Trained Tokens: {data['trained_tokens']:,}")
+
+                if (
+                    "estimated_finish" in data
+                    and data["estimated_finish"]
+                    and data["estimated_finish"] > 0
+                ):
+                    from datetime import datetime
+
+                    est_str = datetime.fromtimestamp(data["estimated_finish"]).strftime(
+                        "%Y-%m-%d %H:%M:%S"
+                    )
+                    hud_console.info(f"Estimated Finish: {est_str}")
+
+                # Only show error if it's actually an error (not empty/null)
+                if data.get("error"):
+                    error = data["error"]
+                    # Check if it's a real error
+                    if isinstance(error, dict):
+                        # Check if any field has actual content
+                        has_content = any(error.get(k) for k in ["code", "message", "param"])
+                        if has_content:
+                            error_msg = error.get("message") or str(error)
+                            hud_console.error(f"Error: {error_msg}")
+                    elif isinstance(error, str) and error.strip():
+                        hud_console.error(f"Error: {error}")
+
+                # Suggest verbose mode for more details
+                console.print("\n[dim]Use --verbose to see full status details[/dim]")
+
+    except httpx.RequestError as e:
+        hud_console.error(f"Connection error: {e}")
+        hud_console.info("Is the RL service running?")
+        raise typer.Exit(1) from e

hud/cli/tests/test_analyze.py

@@ -50,7 +50,7 @@ class TestAnalyzeEnvironment:
         }
 
         with (
-            patch("hud.cli.analyze.MCPClient") as MockClient,
+            patch("hud.clients.fastmcp.FastMCPHUDClient") as MockClient,
             patch("hud.cli.analyze.console"),
             patch("hud.cli.analyze.display_interactive") as mock_interactive,
         ):
@@ -80,7 +80,7 @@ class TestAnalyzeEnvironment:
     async def test_analyze_environment_failure(self) -> None:
         """Test handling analysis failure."""
         with (
-            patch("hud.cli.analyze.MCPClient") as MockClient,
+            patch("hud.clients.fastmcp.FastMCPHUDClient") as MockClient,
             patch("hud.cli.analyze.console") as mock_console,
             patch("platform.system", return_value="Windows"),
         ):
@@ -119,7 +119,7 @@ class TestAnalyzeEnvironment:
 
         for output_format in ["json", "markdown", "interactive"]:
             with (
-                patch("hud.cli.analyze.MCPClient") as MockClient,
+                patch("hud.clients.fastmcp.FastMCPHUDClient") as MockClient,
                 patch("hud.cli.analyze.console") as mock_console,
                 patch("hud.cli.analyze.display_interactive") as mock_interactive,
                 patch("hud.cli.analyze.display_markdown") as mock_markdown,
@@ -163,7 +163,7 @@ class TestAnalyzeWithConfig:
         }
 
         with (
-            patch("hud.cli.analyze.MCPClient") as MockClient,
+            patch("hud.clients.fastmcp.FastMCPHUDClient") as MockClient,
             patch("hud.cli.analyze.console"),
             patch("hud.cli.analyze.display_interactive") as mock_interactive,
         ):
@@ -190,7 +190,7 @@ class TestAnalyzeWithConfig:
         mock_config = {"server": {"command": "test"}}
 
         with (
-            patch("hud.cli.analyze.MCPClient") as MockClient,
+            patch("hud.clients.fastmcp.FastMCPHUDClient") as MockClient,
             patch("hud.cli.analyze.console"),
         ):
             # Setup mock client that fails

hud/cli/tests/test_analyze_metadata.py

@@ -214,6 +214,7 @@ class TestAnalyzeFromMetadata:
 
     @mock.patch("hud.cli.utils.metadata.check_local_cache")
     @mock.patch("hud.cli.utils.metadata.fetch_lock_from_registry")
+    @mock.patch("hud.cli.utils.metadata.hud_console")
     @mock.patch("hud.cli.utils.metadata.console")
     async def test_analyze_not_found(self, mock_console, mock_hud_console, mock_fetch, mock_check):
         """Test when environment not found anywhere."""
@@ -222,9 +223,9 @@ class TestAnalyzeFromMetadata:
 
         await analyze_from_metadata("test/notfound:latest", "json", verbose=False)
 
-        # Should show error
+        # Should show error via hud_console
         mock_hud_console.error.assert_called_with("Environment metadata not found")
-        # Should print suggestions
+        # Should print suggestions via console
         mock_console.print.assert_called()
 
     @mock.patch("hud.cli.utils.metadata.check_local_cache")

hud/cli/tests/test_analyze_module.py

@@ -0,0 +1,120 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import pytest
+
+from hud.cli.analyze import (
+    analyze_environment,
+    analyze_environment_from_config,
+    analyze_environment_from_mcp_config,
+    display_interactive,
+    display_markdown,
+    parse_docker_command,
+)
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+
+# Mark entire module as asyncio to ensure async tests run with pytest-asyncio
+pytestmark = pytest.mark.asyncio
+
+
+def test_parse_docker_command():
+    cmd = ["docker", "run", "--rm", "-i", "img"]
+    cfg = parse_docker_command(cmd)
+    assert cfg == {"local": {"command": "docker", "args": ["run", "--rm", "-i", "img"]}}
+
+
+@pytest.mark.asyncio
+@patch("hud.clients.fastmcp.FastMCPHUDClient")
+@patch("hud.cli.analyze.console")
+async def test_analyze_environment_success_json(mock_console, MockClient):
+    client = AsyncMock()
+    client.initialize.return_value = None
+    client.analyze_environment.return_value = {"tools": [], "resources": []}
+    client.shutdown.return_value = None
+    MockClient.return_value = client
+
+    await analyze_environment(["docker", "run", "img"], output_format="json", verbose=False)
+    assert client.initialize.awaited
+    assert client.analyze_environment.awaited
+    assert client.shutdown.awaited
+    assert mock_console.print_json.called
+
+
+@pytest.mark.asyncio
+@patch("hud.clients.fastmcp.FastMCPHUDClient")
+@patch("hud.cli.analyze.console")
+async def test_analyze_environment_failure(mock_console, MockClient):
+    client = AsyncMock()
+    client.initialize.side_effect = RuntimeError("boom")
+    client.shutdown.return_value = None
+    MockClient.return_value = client
+
+    # Should swallow exception and return without raising
+    await analyze_environment(["docker", "run", "img"], output_format="json", verbose=True)
+    assert client.shutdown.awaited
+    assert mock_console.print_json.called is False
+
+
+def test_display_interactive_metadata_only(monkeypatch):
+    import hud.cli.analyze as mod
+
+    monkeypatch.setattr(mod, "console", MagicMock(), raising=False)
+    monkeypatch.setattr(mod, "hud_console", MagicMock(), raising=False)
+
+    analysis = {
+        "image": "img:latest",
+        "status": "cached",
+        "tool_count": 2,
+        "tools": [
+            {"name": "t1", "description": "d1", "inputSchema": {"type": "object"}},
+            {"name": "t2", "description": "d2"},
+        ],
+        "resources": [],
+    }
+    display_interactive(analysis)
+
+
+def test_display_markdown_both_paths(capsys):
+    # metadata-only
+    md_only = {"image": "img:latest", "tool_count": 0, "tools": [], "resources": []}
+    display_markdown(md_only)
+
+    # live metadata
+    live = {"metadata": {"servers": ["s1"], "initialized": True}, "tools": [], "resources": []}
+    display_markdown(live)
+
+    # Check that output was generated
+    captured = capsys.readouterr()
+    assert "MCP Environment Analysis" in captured.out
+
+
+@patch("hud.clients.fastmcp.FastMCPHUDClient")
+async def test_analyze_environment_from_config(MockClient, tmp_path: Path):
+    client = AsyncMock()
+    client.initialize.return_value = None
+    client.analyze_environment.return_value = {"tools": [], "resources": []}
+    client.shutdown.return_value = None
+    MockClient.return_value = client
+
+    cfg = tmp_path / "mcp.json"
+    cfg.write_text('{"local": {"command": "docker", "args": ["run", "img"]}}')
+    await analyze_environment_from_config(cfg, output_format="json", verbose=False)
+    assert client.initialize.awaited and client.shutdown.awaited
+
+
+@patch("hud.clients.fastmcp.FastMCPHUDClient")
+async def test_analyze_environment_from_mcp_config(MockClient):
+    client = AsyncMock()
+    client.initialize.return_value = None
+    client.analyze_environment.return_value = {"tools": [], "resources": []}
+    client.shutdown.return_value = None
+    MockClient.return_value = client
+
+    mcp_config = {"local": {"command": "docker", "args": ["run", "img"]}}
+    await analyze_environment_from_mcp_config(mcp_config, output_format="json", verbose=False)
+    assert client.initialize.awaited and client.shutdown.awaited

hud/cli/tests/test_build.py

@@ -60,12 +60,12 @@ class TestIncrementVersion:
     def test_increment_minor(self):
         """Test incrementing minor version."""
         assert increment_version("1.2.3", "minor") == "1.3.0"
-        assert increment_version("0.5.10", "minor") == "0.6.0"
+        assert increment_version("0.5.13", "minor") == "0.6.0"
 
     def test_increment_major(self):
         """Test incrementing major version."""
         assert increment_version("1.2.3", "major") == "2.0.0"
-        assert increment_version("0.5.10", "major") == "1.0.0"
+        assert increment_version("0.5.13", "major") == "1.0.0"
 
     def test_increment_with_v_prefix(self):
         """Test incrementing version with v prefix."""
@@ -206,7 +206,7 @@ RUN pip install fastmcp
 class TestAnalyzeMcpEnvironment:
     """Test analyzing MCP environment."""
 
-    @mock.patch("hud.cli.build.MCPClient")
+    @mock.patch("hud.clients.fastmcp.FastMCPHUDClient")
     async def test_analyze_success(self, mock_client_class):
         """Test successful environment analysis."""
         # Setup mock client
@@ -219,6 +219,17 @@ class TestAnalyzeMcpEnvironment:
         mock_tool.description = "Test tool"
         mock_tool.inputSchema = {"type": "object"}
 
+        # Prefer analyze_environment path (aligns with analyze CLI tests)
+        mock_client.analyze_environment = mock.AsyncMock(
+            return_value={
+                "metadata": {"servers": ["local"], "initialized": True},
+                "tools": [{"name": "test_tool", "description": "Test tool"}],
+                "hub_tools": {},
+                "resources": [],
+                "telemetry": {},
+            }
+        )
+        # Fallback still defined for completeness
         mock_client.list_tools.return_value = [mock_tool]
 
         result = await analyze_mcp_environment("test:latest")
@@ -229,7 +240,7 @@ class TestAnalyzeMcpEnvironment:
         assert result["tools"][0]["name"] == "test_tool"
         assert "initializeMs" in result
 
-    @mock.patch("hud.cli.build.MCPClient")
+    @mock.patch("hud.clients.fastmcp.FastMCPHUDClient")
     async def test_analyze_failure(self, mock_client_class):
         """Test failed environment analysis."""
         # Setup mock client to fail
@@ -237,14 +248,25 @@ class TestAnalyzeMcpEnvironment:
         mock_client_class.return_value = mock_client
         mock_client.initialize.side_effect = ConnectionError("Connection failed")
 
-        with pytest.raises(ConnectionError):
+        from hud.shared.exceptions import HudException
+
+        with pytest.raises(HudException, match="Connection failed"):
             await analyze_mcp_environment("test:latest")
 
-    @mock.patch("hud.cli.build.MCPClient")
+    @mock.patch("hud.clients.fastmcp.FastMCPHUDClient")
     async def test_analyze_verbose_mode(self, mock_client_class):
         """Test analysis in verbose mode."""
         mock_client = mock.AsyncMock()
         mock_client_class.return_value = mock_client
+        mock_client.analyze_environment = mock.AsyncMock(
+            return_value={
+                "metadata": {"servers": ["local"], "initialized": True},
+                "tools": [],
+                "hub_tools": {},
+                "resources": [],
+                "telemetry": {},
+            }
+        )
         mock_client.list_tools.return_value = []
 
         # Just test that it runs without error in verbose mode
@@ -312,6 +334,7 @@ class TestBuildEnvironment:
     """Test the main build_environment function."""
 
     @mock.patch("hud.cli.build.build_docker_image")
+    @mock.patch("hud.cli.build.collect_runtime_metadata")
     @mock.patch("hud.cli.build.analyze_mcp_environment")
     @mock.patch("hud.cli.build.save_to_registry")
     @mock.patch("hud.cli.build.get_docker_image_id")
@@ -322,6 +345,7 @@ class TestBuildEnvironment:
         mock_get_id,
         mock_save_registry,
         mock_analyze,
+        mock_collect_runtime,
         mock_build_docker,
         tmp_path,
     ):
@@ -356,6 +380,12 @@ ENV API_KEY
             ],
         }
         mock_get_id.return_value = "sha256:abc123"
+        mock_collect_runtime.return_value = {
+            "python": "3.11.6",
+            "cuda": None,
+            "cudnn": None,
+            "pytorch": None,
+        }
 
         # Mock final rebuild
         mock_result = mock.Mock()
@@ -363,7 +393,7 @@ ENV API_KEY
         mock_run.return_value = mock_result
 
         # Run build
-        build_environment(str(env_dir), "test/env:latest")
+        build_environment(str(env_dir), "test-env:latest")
 
         # Check lock file was created
         lock_file = env_dir / "hud.lock.yaml"
@@ -373,11 +403,83 @@ ENV API_KEY
         with open(lock_file) as f:
             lock_data = yaml.safe_load(f)
 
-        assert lock_data["image"] == "test/env:latest@sha256:abc123"
+        # Lock file format version
+        assert lock_data["version"] == "1.3"
+
+        assert lock_data["images"]["full"] == "test-env:0.1.0@sha256:abc123"
+        assert lock_data["images"]["local"] == "test-env:0.1.0"
         assert lock_data["build"]["version"] == "0.1.0"
+        assert lock_data["build"]["baseImage"] == "python:3.11"
+        assert lock_data["build"]["platform"] == "linux/amd64"
         assert lock_data["environment"]["toolCount"] == 2
+        assert lock_data["environment"]["runtime"]["python"] == "3.11.6"
         assert len(lock_data["tools"]) == 2
 
+    @mock.patch("hud.cli.build.build_docker_image")
+    @mock.patch("hud.cli.build.collect_runtime_metadata")
+    @mock.patch("hud.cli.build.analyze_mcp_environment")
+    @mock.patch("hud.cli.build.save_to_registry")
+    @mock.patch("hud.cli.build.get_docker_image_id")
+    @mock.patch("subprocess.run")
+    def test_build_environment_internal_tools(
+        self,
+        mock_run,
+        mock_get_id,
+        mock_save_registry,
+        mock_analyze,
+        mock_collect_runtime,
+        mock_build_docker,
+        tmp_path,
+    ):
+        """Dispatcher tools should include internalTools in lock, with count."""
+        env_dir = tmp_path / "env-int"
+        env_dir.mkdir()
+        (env_dir / "pyproject.toml").write_text("""
+[tool.hud]
+image = "test/env:dev"
+""")
+        dockerfile = env_dir / "Dockerfile"
+        dockerfile.write_text("""
+FROM python:3.11
+""")
+
+        mock_build_docker.return_value = True
+        mock_analyze.return_value = {
+            "success": True,
+            "toolCount": 1,
+            "internalToolCount": 2,
+            "initializeMs": 500,
+            "tools": [
+                {
+                    "name": "setup",
+                    "description": "setup dispatcher",
+                    "inputSchema": {"type": "object"},
+                    "internalTools": ["board", "seed"],
+                }
+            ],
+        }
+        mock_get_id.return_value = "sha256:fff111"
+        mock_collect_runtime.return_value = {
+            "python": "3.11.6",
+            "cuda": None,
+            "cudnn": None,
+            "pytorch": None,
+        }
+
+        mock_result = mock.Mock()
+        mock_result.returncode = 0
+        mock_run.return_value = mock_result
+
+        build_environment(str(env_dir), "env-int:latest")
+
+        lock_file = env_dir / "hud.lock.yaml"
+        with open(lock_file) as f:
+            data = yaml.safe_load(f)
+        assert data["version"] == "1.3"
+        assert data["environment"]["internalToolCount"] == 2
+        assert data["tools"][0]["name"] == "setup"
+        assert data["tools"][0]["internalTools"] == ["board", "seed"]
+
     def test_build_environment_no_directory(self):
         """Test build when directory doesn't exist."""
         with pytest.raises(typer.Exit):

hud/cli/tests/test_build_failure.py

@@ -0,0 +1,41 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+from unittest.mock import patch
+
+import pytest
+import typer
+
+from hud.cli.build import build_environment
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+
+@patch("hud.cli.build.compute_source_hash", return_value="deadbeef")
+@patch(
+    "hud.cli.build.analyze_mcp_environment",
+    return_value={"initializeMs": 10, "toolCount": 0, "tools": []},
+)
+@patch("hud.cli.build.build_docker_image", return_value=True)
+def test_build_label_rebuild_failure(_bd, _an, _hash, tmp_path: Path, monkeypatch):
+    # Minimal environment dir
+    env = tmp_path / "env"
+    env.mkdir()
+    (env / "Dockerfile").write_text("FROM python:3.11")
+
+    # Ensure subprocess.run returns non-zero for the second build (label build)
+    import types
+
+    def run_side_effect(cmd, *a, **k):
+        # Return 0 for first docker build, 1 for label build
+        if isinstance(cmd, list) and cmd[:2] == ["docker", "build"] and "--label" in cmd:
+            return types.SimpleNamespace(returncode=1, stderr="boom")
+        return types.SimpleNamespace(returncode=0, stdout="")
+
+    monkeypatch.setenv("FASTMCP_DISABLE_BANNER", "1")
+    with (
+        patch("hud.cli.build.subprocess.run", side_effect=run_side_effect),
+        pytest.raises(typer.Exit),
+    ):
+        build_environment(str(env), verbose=False)

hud/cli/tests/test_build_module.py

@@ -0,0 +1,50 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+from unittest import mock
+
+from hud.cli.build import (
+    extract_env_vars_from_dockerfile,
+    get_docker_image_digest,
+    get_docker_image_id,
+)
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+
+def test_extract_env_vars_from_dockerfile_complex(tmp_path: Path):
+    dockerfile = tmp_path / "Dockerfile"
+    dockerfile.write_text(
+        """
+FROM python:3.11
+ARG BUILD_TOKEN
+ARG DEFAULTED=1
+ENV RUNTIME_KEY
+ENV FROM_ARG=$BUILD_TOKEN
+ENV WITH_DEFAULT=val
+"""
+    )
+    required, optional = extract_env_vars_from_dockerfile(dockerfile)
+    # BUILD_TOKEN required (ARG without default)
+    assert "BUILD_TOKEN" in required
+    # RUNTIME_KEY required (ENV without value)
+    assert "RUNTIME_KEY" in required
+    # FROM_ARG references BUILD_TOKEN -> required
+    assert "FROM_ARG" in required
+    # DEFAULTED and WITH_DEFAULT should not be marked required by default
+    assert "DEFAULTED" not in required
+    assert "WITH_DEFAULT" not in required
+    assert optional == []
+
+
+@mock.patch("subprocess.run")
+def test_get_docker_image_digest_none(mock_run):
+    mock_run.return_value = mock.Mock(stdout="[]", returncode=0)
+    assert get_docker_image_digest("img") is None
+
+
+@mock.patch("subprocess.run")
+def test_get_docker_image_id_ok(mock_run):
+    mock_run.return_value = mock.Mock(stdout="sha256:abc", returncode=0)
+    assert get_docker_image_id("img") == "sha256:abc"

hud/cli/tests/test_cli_init.py

@@ -193,10 +193,15 @@ class TestCLICommands:
 
     def test_version_command(self) -> None:
         """Test version command."""
+        import re
+
+        # Strip ANSI escape codes
+        ansi_escape = re.compile(r"\x1b\[[0-9;]*m")
         with patch("hud.__version__", "1.2.3"):
             result = runner.invoke(app, ["version"])
             assert result.exit_code == 0
-            assert "1.2.3" in result.output
+            clean_output = ansi_escape.sub("", result.output)
+            assert "1.2.3" in clean_output
 
     def test_version_import_error(self) -> None:
         """Test version command when version unavailable."""

hud/cli/tests/test_cli_more_wrappers.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+from unittest.mock import patch
+
+import hud.cli as cli
+
+
+def test_version_does_not_crash():
+    # Just ensure it runs without raising
+    cli.version()
+
+
+@patch("hud.cli.list_module.list_command")
+def test_list_environments_wrapper(mock_list):
+    cli.list_environments(filter_name=None, json_output=False, show_all=False, verbose=False)
+    assert mock_list.called
+
+
+@patch("hud.cli.clone_repository", return_value=(True, "/tmp/repo"))
+@patch("hud.cli.get_clone_message", return_value={})
+@patch("hud.cli.print_tutorial")
+def test_clone_wrapper(mock_tutorial, _msg, _clone):
+    cli.clone("https://example.com/repo.git")
+    assert mock_tutorial.called
+
+
+@patch("hud.cli.remove_command")
+def test_remove_wrapper(mock_remove):
+    cli.remove(target="all", yes=True, verbose=False)
+    assert mock_remove.called