hud-python 0.4.51__py3-none-any.whl → 0.4.53__py3-none-any.whl

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

hud/cli/tests/test_cli_root.py

@@ -0,0 +1,134 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+from unittest.mock import AsyncMock, patch
+
+import pytest
+
+import hud.cli as cli
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+
+@patch("hud.cli.utils.metadata.analyze_from_metadata", new_callable=AsyncMock)
+@patch("asyncio.run")
+def test_analyze_params_metadata(mock_run, mock_analyze):
+    # image only -> metadata path
+    cli.analyze(params=["img:latest"], output_format="json", verbose=False)
+    assert mock_run.called
+
+
+@patch("hud.cli.analyze.analyze_environment", new_callable=AsyncMock)
+@patch("hud.cli.utils.docker.build_run_command")
+@patch("asyncio.run")
+def test_analyze_params_live(mock_run, mock_build_cmd, mock_analyze_env):
+    mock_build_cmd.return_value = ["docker", "run", "img", "-e", "K=V"]
+    # docker args trigger live path
+    cli.analyze(params=["img:latest", "-e", "K=V"], output_format="json", verbose=True)
+    assert mock_run.called
+
+
+def test_analyze_no_params_errors():
+    import typer
+
+    # When no params provided, analyze prints help and exits(1)
+    with pytest.raises(typer.Exit):
+        cli.analyze(params=None, config=None, cursor=None, output_format="json", verbose=False)  # type: ignore
+
+
+@patch("hud.cli.analyze.analyze_environment_from_config", new_callable=AsyncMock)
+@patch("asyncio.run")
+def test_analyze_from_config(mock_run, mock_func, tmp_path: Path):
+    cfg = tmp_path / "cfg.json"
+    cfg.write_text("{}")
+    cli.analyze(params=None, config=cfg, cursor=None, output_format="json", verbose=False)  # type: ignore
+    assert mock_run.called
+
+
+@patch("hud.cli.parse_cursor_config")
+@patch("hud.cli.analyze.analyze_environment_from_mcp_config", new_callable=AsyncMock)
+@patch("asyncio.run")
+def test_analyze_from_cursor(mock_run, mock_analyze, mock_parse):
+    mock_parse.return_value = (["cmd", "arg"], None)
+    cli.analyze(params=None, config=None, cursor="server", output_format="json", verbose=False)  # type: ignore
+    assert mock_run.called
+
+
+@patch("hud.cli.build_command")
+def test_build_env_var_parsing(mock_build):
+    cli.build(
+        params=[".", "-e", "A=B", "--env=C=D", "--env", "E=F"],
+        tag=None,
+        no_cache=False,
+        verbose=False,
+        platform=None,
+    )
+    assert mock_build.called
+    # args: directory, tag, no_cache, verbose, env_vars, platform
+    env_vars = mock_build.call_args[0][4]
+    assert env_vars == {"A": "B", "C": "D", "E": "F"}
+
+
+@patch("hud.cli.utils.runner.run_mcp_server")
+def test_run_local_calls_runner(mock_runner):
+    cli.run(
+        params=["img:latest"],
+        local=True,
+        transport="stdio",
+        port=1234,
+        url=None,  # type: ignore
+        api_key=None,
+        run_id=None,
+        verbose=False,
+    )
+    assert mock_runner.called
+
+
+@patch("hud.cli.utils.remote_runner.run_remote_server")
+def test_run_remote_calls_remote(mock_remote):
+    cli.run(
+        params=["img:latest"],
+        local=False,
+        transport="http",
+        port=8765,
+        url="https://x",
+        api_key=None,
+        run_id=None,
+        verbose=True,
+    )
+    assert mock_remote.called
+
+
+def test_run_no_params_errors():
+    import typer
+
+    with pytest.raises(typer.Exit):
+        cli.run(params=None)  # type: ignore
+
+
+@patch("hud.cli.run_mcp_dev_server")
+def test_dev_calls_runner(mock_dev):
+    cli.dev(
+        params=["server.main"],
+        docker=False,
+        stdio=False,
+        port=9000,
+        verbose=False,
+        inspector=False,
+        interactive=False,
+        watch=None,  # type: ignore
+    )
+    assert mock_dev.called
+
+
+@patch("hud.cli.pull_command")
+def test_pull_command_wrapper(mock_pull):
+    cli.pull(target="org/name:tag", lock_file=None, yes=True, verify_only=True, verbose=False)
+    assert mock_pull.called
+
+
+@patch("hud.cli.push_command")
+def test_push_command_wrapper(mock_push, tmp_path: Path):
+    cli.push(directory=str(tmp_path), image=None, tag=None, sign=False, yes=True, verbose=True)
+    assert mock_push.called

hud/cli/tests/test_eval.py

@@ -332,6 +332,7 @@ class TestRunDatasetToolFiltering:
             patch.object(ClaudeAgent, "_run_context", mock_run_context),
             patch.object(ClaudeAgent, "call_tools", mock_call_tools),
             patch("hud.clients.MCPClient", return_value=mock_client_instance),
+            patch("hud.settings.settings.anthropic_api_key", "sk-test-key"),
         ):
             # Run the dataset
             await run_dataset(
@@ -400,6 +401,7 @@ class TestRunDatasetToolFiltering:
             patch.object(ClaudeAgent, "_run_context", mock_run_context),
             patch.object(ClaudeAgent, "call_tools", mock_call_tools),
             patch("hud.clients.MCPClient", return_value=mock_client_instance),
+            patch("hud.settings.settings.anthropic_api_key", "sk-test-key"),
         ):
             # Run the dataset
             await run_dataset(
@@ -500,6 +502,7 @@ class TestSystemPromptHandling:
             patch.object(ClaudeAgent, "_run_context", mock_run_context),
             patch.object(ClaudeAgent, "call_tools", mock_call_tools),
             patch("hud.clients.MCPClient", return_value=mock_mcp_client),
+            patch("hud.settings.settings.anthropic_api_key", "sk-test-key"),
         ):
             # Run the dataset
             await run_dataset(
@@ -551,6 +554,7 @@ class TestSystemPromptHandling:
             patch.object(ClaudeAgent, "_run_context", mock_run_context),
             patch.object(ClaudeAgent, "call_tools", mock_call_tools),
             patch("hud.clients.MCPClient", return_value=mock_mcp_client),
+            patch("hud.settings.settings.anthropic_api_key", "sk-test-key"),
         ):
             # Run the dataset
             await run_dataset(

hud/cli/tests/test_mcp_server.py

@@ -15,22 +15,23 @@ class TestRunMCPDevServer:
     """Test the main server runner."""
 
     def test_run_dev_server_image_not_found(self) -> None:
-        """Test handling when Docker image doesn't exist."""
-        import click
+        """When using Docker mode without a lock file, exits with typer.Exit(1)."""
+        import typer
 
         with (
-            patch("hud.cli.dev.image_exists", return_value=False),
-            patch("click.confirm", return_value=False),
-            pytest.raises(click.Abort),
+            patch("hud.cli.dev.should_use_docker_mode", return_value=True),
+            patch("hud.cli.dev.Path.cwd"),
+            patch("hud.cli.dev.hud_console"),
+            pytest.raises(typer.Exit),
         ):
             run_mcp_dev_server(
-                module=".",
+                module=None,
                 stdio=False,
                 port=8765,
                 verbose=False,
                 inspector=False,
                 interactive=False,
                 watch=[],
-                docker=False,
+                docker=True,
                 docker_args=[],
             )

hud/cli/tests/test_push_happy.py

@@ -0,0 +1,74 @@
+from __future__ import annotations
+
+from types import SimpleNamespace
+from typing import TYPE_CHECKING
+from unittest.mock import patch
+
+from hud.cli.push import push_environment
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+
+@patch("hud.cli.push.get_docker_username", return_value="tester")
+@patch(
+    "hud.cli.push.get_docker_image_labels",
+    return_value={"org.hud.manifest.head": "abc", "org.hud.version": "0.1.0"},
+)
+@patch("hud.cli.push.requests.post")
+@patch("hud.cli.push.subprocess.Popen")
+@patch("hud.cli.push.subprocess.run")
+def test_push_happy_path(
+    mock_run, mock_popen, mock_post, _labels, _user, tmp_path: Path, monkeypatch
+):
+    # Prepare minimal environment with lock file
+    env_dir = tmp_path
+    (env_dir / "hud.lock.yaml").write_text(
+        "images:\n  local: org/env:latest\nbuild:\n  version: 0.1.0\n"
+    )
+
+    # Provide API key via main settings module
+    monkeypatch.setattr("hud.settings.settings.api_key", "sk-test", raising=False)
+
+    # ensure_built noop - patch from the right module
+    monkeypatch.setattr("hud.cli.utils.env_check.ensure_built", lambda *_a, **_k: {})
+
+    # Mock subprocess.run behavior depending on command
+    def run_side_effect(args, *a, **k):
+        cmd = list(args)
+        # docker inspect checks
+        if cmd[:2] == ["docker", "inspect"]:
+            # For label digest query at end
+            if "--format" in cmd and "{{index .RepoDigests 0}}" in cmd:
+                return SimpleNamespace(returncode=0, stdout="org/env@sha256:deadbeef")
+            # Existence checks succeed
+            return SimpleNamespace(returncode=0, stdout="")
+        # docker tag success
+        if cmd[:2] == ["docker", "tag"]:
+            return SimpleNamespace(returncode=0, stdout="")
+        return SimpleNamespace(returncode=0, stdout="")
+
+    mock_run.side_effect = run_side_effect
+
+    # Mock Popen push pipeline
+    class _Proc:
+        def __init__(self):
+            self.stdout = ["digest: sha256:deadbeef\n", "pushed\n"]
+            self.returncode = 0
+
+        def wait(self):
+            return 0
+
+    mock_popen.return_value = _Proc()
+
+    # Mock registry POST success
+    mock_post.return_value = SimpleNamespace(status_code=201, json=lambda: {"ok": True}, text="")
+
+    # Execute
+    push_environment(
+        directory=str(env_dir), image=None, tag=None, sign=False, yes=True, verbose=False
+    )
+
+    # Lock file updated with pushed entry
+    data = (env_dir / "hud.lock.yaml").read_text()
+    assert "pushed:" in data

hud/cli/tests/test_push_wrapper.py

@@ -0,0 +1,23 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+from unittest.mock import patch
+
+import pytest
+import typer
+
+from hud.cli.push import push_environment
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+
+@patch("hud.cli.push.ensure_built")
+@patch("hud.cli.push.HUDConsole")
+@patch("hud.cli.push.subprocess.run")
+def test_push_environment_missing_lock_raises(mock_run, mock_console, _ensure, tmp_path: Path):
+    # No hud.lock.yaml → Exit(1)
+    with pytest.raises(typer.Exit):
+        push_environment(
+            directory=str(tmp_path), image=None, tag=None, sign=False, yes=True, verbose=False
+        )

hud/cli/utils/docker.py

@@ -1,4 +1,9 @@
-"""Docker utilities for HUD CLI."""
+"""Docker utilities for HUD CLI.
+
+This module centralizes helpers for constructing Docker commands and
+standardizes environment variable handling for "folder mode" (environment
+directories that include a `.env` file and/or `hud.lock.yaml`).
+"""
 
 from __future__ import annotations
 
@@ -6,6 +11,12 @@ import json
 import platform
 import shutil
 import subprocess
+from pathlib import Path
+
+from .config import parse_env_file
+
+# Note: we deliberately avoid the stricter is_environment_directory() check here
+# to allow folder mode with only a Dockerfile or only a pyproject.toml.
 
 
 def get_docker_cmd(image: str) -> list[str] | None:
@@ -103,6 +114,114 @@ def build_run_command(image: str, docker_args: list[str] | None = None) -> list[
     ]
 
 
+def detect_environment_dir(start_dir: Path | None = None) -> Path | None:
+    """Detect an environment directory for folder mode.
+
+    Detection order:
+    - Current directory containing `hud.lock.yaml`
+    - Parent directory containing `hud.lock.yaml`
+    - Current directory that looks like an environment if it has either a
+      `Dockerfile` or a `pyproject.toml` (looser than `is_environment_directory`).
+
+    Returns the detected directory path or None if not found.
+    """
+    base = (start_dir or Path.cwd()).resolve()
+
+    # Check current then parent for lock file
+    for candidate in [base, base.parent]:
+        if (candidate / "hud.lock.yaml").exists():
+            return candidate
+
+    # Fallback: treat as env if it has Dockerfile OR pyproject.toml
+    if (base / "Dockerfile").exists() or (base / "pyproject.toml").exists():
+        return base
+
+    return None
+
+
+def load_env_vars_for_dir(env_dir: Path) -> dict[str, str]:
+    """Load KEY=VALUE pairs from `<env_dir>/.env` if present.
+
+    Returns an empty dict if no file is found or parsing fails.
+    """
+    env_file = env_dir / ".env"
+    if not env_file.exists():
+        return {}
+    try:
+        contents = env_file.read_text(encoding="utf-8")
+        return parse_env_file(contents)
+    except Exception:
+        return {}
+
+
+def build_env_flags(env_vars: dict[str, str]) -> list[str]:
+    """Convert an env dict into a flat list of `-e KEY=VALUE` flags."""
+    flags: list[str] = []
+    for key, value in env_vars.items():
+        flags.extend(["-e", f"{key}={value}"])
+    return flags
+
+
+def create_docker_run_command(
+    image: str,
+    docker_args: list[str] | None = None,
+    env_dir: Path | str | None = None,
+    extra_env: dict[str, str] | None = None,
+    name: str | None = None,
+    interactive: bool = True,
+    remove: bool = True,
+) -> list[str]:
+    """Create a standardized `docker run` command with folder-mode envs.
+
+    - If `env_dir` is provided (or auto-detected), `.env` entries are injected as
+      `-e KEY=VALUE` flags before the image.
+    - `extra_env` allows callers to provide additional env pairs that override
+      variables from `.env`.
+
+    Args:
+        image: Docker image to run
+        docker_args: Additional docker args (volumes, ports, etc.)
+        env_dir: Environment directory to load `.env` from; if None, auto-detect
+        extra_env: Additional env variables to inject (takes precedence)
+        name: Optional container name
+        interactive: Include `-i` flag (default True)
+        remove: Include `--rm` flag (default True)
+
+    Returns:
+        Fully constructed docker run command
+    """
+    cmd: list[str] = ["docker", "run"]
+    if remove:
+        cmd.append("--rm")
+    if interactive:
+        cmd.append("-i")
+    if name:
+        cmd.extend(["--name", name])
+
+    # Load env from `.env` in detected env directory
+    env_dir_path: Path | None = (
+        Path(env_dir).resolve() if isinstance(env_dir, (str, Path)) else detect_environment_dir()
+    )
+
+    merged_env: dict[str, str] = {}
+    if env_dir_path is not None:
+        merged_env.update(load_env_vars_for_dir(env_dir_path))
+    if extra_env:
+        # Caller-provided values override .env
+        merged_env.update(extra_env)
+
+    # Insert env flags before other args
+    if merged_env:
+        cmd.extend(build_env_flags(merged_env))
+
+    # Add remaining args (volumes, ports, etc.)
+    if docker_args:
+        cmd.extend(docker_args)
+
+    cmd.append(image)
+    return cmd
+
+
 def _emit_docker_hints(error_text: str) -> None:
     """Parse common Docker connectivity errors and print platform-specific hints."""
     from hud.utils.hud_console import hud_console

hud/cli/utils/runner.py

@@ -16,7 +16,7 @@ def run_stdio_server(image: str, docker_args: list[str], verbose: bool) -> None:
     """Run Docker image as stdio MCP server (direct passthrough)."""
     hud_console = HUDConsole()  # Use stderr for stdio mode
 
-    # Build docker command
+    # Build docker command (image-only mode: do not auto-inject local .env)
     docker_cmd = ["docker", "run", "--rm", "-i", *docker_args, image]
 
     if verbose:

hud/cli/utils/tasks.py

@@ -18,9 +18,12 @@ def find_tasks_file(tasks_file: str | None, msg: str = "Select a tasks file") ->
     ]
     all_files = [file for file in all_files if file[0] != "."]  # Remove all config files
 
+    if not all_files:
+        # No task files found - raise a clear exception
+        raise FileNotFoundError("No task JSON or JSONL files found in current directory")
+
     if len(all_files) == 1:
         return str(all_files[0])
-
     else:
         # Prompt user to select a file
         return hud_console.select(msg, choices=all_files)

hud/cli/utils/tests/test_config.py

@@ -0,0 +1,58 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from hud.cli.utils.config import (
+    ensure_config_dir,
+    get_config_dir,
+    get_user_env_path,
+    load_env_file,
+    parse_env_file,
+    render_env_file,
+    save_env_file,
+)
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+
+def test_parse_env_file_basic():
+    contents = """
+# comment
+KEY=VALUE
+EMPTY=
+NOEQ
+ SPACED = v 
+"""  # noqa: W291
+    data = parse_env_file(contents)
+    assert data["KEY"] == "VALUE"
+    assert data["EMPTY"] == ""
+    assert data["SPACED"] == "v"
+    assert "NOEQ" not in data
+
+
+def test_render_and_load_roundtrip(tmp_path: Path):
+    env = {"A": "1", "B": "2"}
+    file_path = tmp_path / ".env"
+    rendered = render_env_file(env)
+    file_path.write_text(rendered, encoding="utf-8")
+    loaded = load_env_file(file_path)
+    assert loaded == env
+
+
+def test_get_paths(monkeypatch, tmp_path: Path):
+    from pathlib import Path as _Path
+
+    monkeypatch.setattr(_Path, "home", lambda: tmp_path)
+    cfg = get_config_dir()
+    assert str(cfg).replace("\\", "/").endswith("/.hud")
+    assert str(get_user_env_path()).replace("\\", "/").endswith("/.hud/.env")
+
+
+def test_ensure_and_save(tmp_path: Path, monkeypatch):
+    monkeypatch.setenv("HOME", str(tmp_path))
+    cfg = ensure_config_dir()
+    assert cfg.exists()
+    out = save_env_file({"K": "V"})
+    assert out.exists()
+    assert load_env_file(out) == {"K": "V"}

hud/cli/utils/tests/test_docker.py

@@ -0,0 +1,93 @@
+from __future__ import annotations
+
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from hud.cli.utils.docker import (
+    build_run_command,
+    generate_container_name,
+    get_docker_cmd,
+    image_exists,
+    remove_container,
+    require_docker_running,
+)
+
+
+def test_build_run_command_basic():
+    cmd = build_run_command("my-image:latest")
+    assert cmd[:4] == ["docker", "run", "--rm", "-i"]
+    assert cmd[-1] == "my-image:latest"
+
+
+def test_build_run_command_with_args():
+    cmd = build_run_command("img", ["-e", "K=V", "-p", "8080:8080"])
+    assert "-e" in cmd and "K=V" in cmd
+    assert "-p" in cmd and "8080:8080" in cmd
+    assert cmd[-1] == "img"
+
+
+def test_generate_container_name():
+    assert generate_container_name("repo/name:tag") == "hud-repo-name-tag"
+    assert generate_container_name("a/b:c", prefix="x") == "x-a-b-c"
+
+
+@patch("subprocess.run")
+def test_image_exists_true(mock_run):
+    mock_run.return_value = MagicMock(returncode=0)
+    assert image_exists("any") is True
+
+
+@patch("subprocess.run")
+def test_image_exists_false(mock_run):
+    mock_run.return_value = MagicMock(returncode=1)
+    assert image_exists("any") is False
+
+
+@patch("subprocess.run")
+def test_get_docker_cmd_success(mock_run):
+    mock_run.return_value = MagicMock(
+        stdout='[{"Config": {"Cmd": ["python", "-m", "app"]}}]', returncode=0
+    )
+    assert get_docker_cmd("img") == ["python", "-m", "app"]
+
+
+@patch("subprocess.run")
+def test_get_docker_cmd_none(mock_run):
+    mock_run.return_value = MagicMock(stdout="[]", returncode=0)
+    assert get_docker_cmd("img") is None
+
+
+@patch("subprocess.run")
+def test_remove_container_ok(mock_run):
+    mock_run.return_value = MagicMock(returncode=0)
+    assert remove_container("x") is True
+
+
+@patch("shutil.which", return_value=None)
+def test_require_docker_running_no_cli(_which):
+    import typer
+
+    with pytest.raises(typer.Exit):
+        require_docker_running()
+
+
+@patch("shutil.which", return_value="docker")
+@patch("subprocess.run")
+def test_require_docker_running_ok(mock_run, _which):
+    mock_run.return_value = MagicMock(returncode=0, stdout="", stderr="")
+    require_docker_running()  # should not raise
+
+
+@patch("shutil.which", return_value="docker")
+@patch("subprocess.run")
+def test_require_docker_running_error_emits_hints(mock_run, _which):
+    import typer
+
+    mock_run.return_value = MagicMock(
+        returncode=1,
+        stdout="Cannot connect to the Docker daemon",
+        stderr="",
+    )
+    with pytest.raises(typer.Exit):
+        require_docker_running()