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

hud/utils/hud_console.py

@@ -20,8 +20,6 @@ import time
 import traceback
 from typing import TYPE_CHECKING, Any, Literal, Self
 
-import questionary
-import typer
 from rich.console import Console
 from rich.panel import Panel
 from rich.table import Table
@@ -38,9 +36,26 @@ TEXT = "bright_white"  # Off-white that's readable on dark, not too bright on li
 SECONDARY = "rgb(108,113,196)"  # Muted blue-purple for secondary text
 
 
+# HUD Symbol System - Minimal 3-category system with default colors
+class Symbols:
+    """Unicode symbols for consistent CLI output with default colors."""
+
+    # Info/Items - Use for all informational lines (gold)
+    ITEM = f"[{GOLD}]•[/{GOLD}]"
+
+    # Status - Use for state/completion (green)
+    SUCCESS = f"[{GREEN}]●[/{GREEN}]"
+
+    # Flow/Special - Use for transitions and important notes (gold)
+    FLOW = f"[{GOLD}]⟿[/{GOLD}]"
+
+
 class HUDConsole:
     """Design system for HUD CLI output."""
 
+    # Make symbols easily accessible
+    sym = Symbols
+
     def __init__(self, logger: logging.Logger | None = None) -> None:
         """Initialize the design system.
 
@@ -470,6 +485,9 @@ class HUDConsole:
         Returns:
             The selected choice value
         """
+        import questionary
+        from questionary import Style
+
         # Convert choices to questionary format
         q_choices = []
 
@@ -481,15 +499,27 @@ class HUDConsole:
             else:
                 q_choices.append(choice)
 
+        # Custom style for better visibility of selection
+        custom_style = Style(
+            [
+                ("qmark", "fg:cyan bold"),
+                ("question", "bold"),
+                ("pointer", "fg:cyan bold"),
+                ("highlighted", "fg:cyan bold"),
+            ]
+        )
+
         result = questionary.select(
             message,
             choices=q_choices,
-            default=q_choices[default] if default is not None else None,
             instruction="(Use ↑/↓ arrows, Enter to select)",
+            style=custom_style,
         ).ask()
 
         # If no selection made (Ctrl+C or ESC), exit
         if result is None:
+            import typer
+
             raise typer.Exit(1)
 
         return result
@@ -545,8 +575,36 @@ class HUDConsole:
             message: The confirmation message
             default: If True, the default choice is True
         """
+        import questionary
+
         return questionary.confirm(message, default=default).ask()
 
+    # Symbol-based output methods
+    def symbol(self, symbol: str, message: str, color: str = GOLD, stderr: bool = True) -> None:
+        """Print a message with a colored symbol prefix.
+
+        Args:
+            symbol: Symbol to use (use Symbols.* constants)
+            message: Message text
+            color: Color for the symbol (default: gold)
+            stderr: If True, output to stderr
+        """
+        console = self._stderr_console if stderr else self._stdout_console
+        console.print(f"[{color}]{symbol}[/{color}] {message}")
+
+    def detail(self, message: str, stderr: bool = True) -> None:
+        """Print an indented detail line with gold pointer symbol."""
+        console = self._stderr_console if stderr else self._stdout_console
+        console.print(f"  [{GOLD}]{Symbols.ITEM}[/{GOLD}] {message}")
+
+    def flow(self, message: str, stderr: bool = True) -> None:
+        """Print a flow/transition message with wave symbol."""
+        self.symbol(Symbols.FLOW, message, GOLD, stderr)
+
+    def note(self, message: str, stderr: bool = True) -> None:
+        """Print an important note with asterism symbol."""
+        self.symbol(Symbols.ITEM, message, GOLD, stderr)
+
 
 # Global design instance for convenience
 class _ProgressContext:

hud/utils/mcp.py

@@ -5,8 +5,6 @@ from typing import Any
 
 from pydantic import BaseModel, Field
 
-from hud.settings import settings
-
 logger = logging.getLogger(__name__)
 
 
@@ -17,15 +15,27 @@ class MCPConfigPatch(BaseModel):
     meta: dict[str, Any] | None = Field(default_factory=dict, alias="meta")
 
 
+def _is_hud_server(url: str) -> bool:
+    """Check if a URL is a HUD MCP server.
+
+    Matches:
+    - Any mcp.hud.* domain (including .ai, .so, and future domains)
+    - Staging servers (orcstaging.hud.so)
+    - Any *.hud.ai or *.hud.so domain
+    """
+    if not url:
+        return False
+    url_lower = url.lower()
+    return "mcp.hud." in url_lower or ".hud.ai" in url_lower or ".hud.so" in url_lower
+
+
 def patch_mcp_config(mcp_config: dict[str, dict[str, Any]], patch: MCPConfigPatch) -> None:
     """Patch MCP config with additional values."""
-    hud_mcp_url = settings.hud_mcp_url
-
     for server_cfg in mcp_config.values():
         url = server_cfg.get("url", "")
 
         # 1) HTTP header lane (only for hud MCP servers)
-        if hud_mcp_url in url and patch.headers:
+        if _is_hud_server(url) and patch.headers:
             for key, value in patch.headers.items():
                 headers = server_cfg.setdefault("headers", {})
                 headers.setdefault(key, value)
@@ -35,56 +45,3 @@ def patch_mcp_config(mcp_config: dict[str, dict[str, Any]], patch: MCPConfigPatc
             for key, value in patch.meta.items():
                 meta = server_cfg.setdefault("meta", {})
                 meta.setdefault(key, value)
-
-
-def setup_hud_telemetry(
-    mcp_config: dict[str, dict[str, Any]], auto_trace: bool = True
-) -> Any | None:
-    """Setup telemetry for hud servers.
-
-    Returns:
-        The auto-created trace context manager if one was created, None otherwise.
-        Caller is responsible for exiting the context manager.
-    """
-    if not mcp_config:
-        raise ValueError("Please run initialize() before setting up client-side telemetry")
-
-    # Check if there are any HUD servers to setup telemetry for
-    hud_mcp_url = settings.hud_mcp_url
-    has_hud_servers = any(
-        hud_mcp_url in server_cfg.get("url", "") for server_cfg in mcp_config.values()
-    )
-
-    # If no HUD servers, no need for telemetry setup
-    if not has_hud_servers:
-        return None
-
-    from hud.otel import get_current_task_run_id
-    from hud.telemetry import trace
-
-    run_id = get_current_task_run_id()
-    auto_trace_cm = None
-
-    if not run_id and auto_trace:
-        # Start an auto trace and capture its ID for headers/metadata
-        auto_trace_cm = trace("My Trace")
-        _trace_obj = auto_trace_cm.__enter__()
-        try:
-            run_id = getattr(_trace_obj, "id", None) or str(_trace_obj)
-        except Exception:  # pragma: no cover - fallback shouldn't fail lint
-            run_id = None
-
-    # Patch HUD servers with run-id (works whether auto or user trace)
-    if run_id:
-        patch_mcp_config(
-            mcp_config,
-            MCPConfigPatch(headers={"Run-Id": run_id}, meta={"run_id": run_id}),
-        )
-
-    if settings.api_key:
-        patch_mcp_config(
-            mcp_config,
-            MCPConfigPatch(headers={"Authorization": f"Bearer {settings.api_key}"}),
-        )
-
-    return auto_trace_cm

hud/utils/strict_schema.py

@@ -0,0 +1,162 @@
+"""Utilities to convert JSON schemas into OpenAI's strict format."""
+
+from __future__ import annotations
+
+from typing import Any, TypeGuard
+
+_EMPTY_SCHEMA = {
+    "additionalProperties": False,
+    "type": "object",
+    "properties": {},
+    "required": [],
+}
+
+
+def ensure_strict_json_schema(schema: dict[str, Any]) -> dict[str, Any]:
+    """Ensure a JSON schema conforms to OpenAI's strict requirements.
+
+    This mutates the provided schema in-place and returns it for convenience.
+    """
+    if schema == {}:
+        return _EMPTY_SCHEMA.copy()
+    return _ensure_strict_json_schema(schema, path=(), root=schema)
+
+
+def _ensure_strict_json_schema(
+    json_schema: object,
+    *,
+    path: tuple[str, ...],
+    root: dict[str, Any],
+) -> dict[str, Any]:
+    if not _is_dict(json_schema):
+        raise TypeError(f"Expected {json_schema} to be a dictionary; path={path}")
+
+    defs = json_schema.get("$defs")
+    if _is_dict(defs):
+        for def_name, def_schema in defs.items():
+            _ensure_strict_json_schema(def_schema, path=(*path, "$defs", def_name), root=root)
+
+    definitions = json_schema.get("definitions")
+    if _is_dict(definitions):
+        for definition_name, definition_schema in definitions.items():
+            _ensure_strict_json_schema(
+                definition_schema, path=(*path, "definitions", definition_name), root=root
+            )
+
+    typ = json_schema.get("type")
+    if typ == "object":
+        if "additionalProperties" not in json_schema or json_schema["additionalProperties"] is True:
+            json_schema["additionalProperties"] = False
+        elif (
+            json_schema["additionalProperties"] and json_schema["additionalProperties"] is not False
+        ):
+            raise ValueError(
+                "additionalProperties should not be set for object types in strict mode."
+            )
+
+    properties = json_schema.get("properties")
+    if _is_dict(properties):
+        json_schema["required"] = list(properties.keys())
+        json_schema["properties"] = {
+            key: _ensure_strict_json_schema(prop_schema, path=(*path, "properties", key), root=root)
+            for key, prop_schema in properties.items()
+        }
+
+    items = json_schema.get("items")
+    if _is_dict(items):
+        json_schema["items"] = _ensure_strict_json_schema(items, path=(*path, "items"), root=root)
+
+    prefix_items = json_schema.get("prefixItems")
+    if _is_list(prefix_items) and prefix_items:
+        item_types = set()
+        for item in prefix_items:
+            if _is_dict(item) and "type" in item:
+                item_types.add(item["type"])
+
+        if len(item_types) == 1:
+            item_type = item_types.pop()
+            json_schema["items"] = {"type": item_type}
+        else:
+            json_schema["items"] = {"type": "integer"}
+
+        tuple_length = len(prefix_items)
+        json_schema["minItems"] = tuple_length
+        json_schema["maxItems"] = tuple_length
+        json_schema.pop("prefixItems")
+
+    any_of = json_schema.get("anyOf")
+    if _is_list(any_of):
+        json_schema["anyOf"] = [
+            _ensure_strict_json_schema(variant, path=(*path, "anyOf", str(i)), root=root)
+            for i, variant in enumerate(any_of)
+        ]
+
+    one_of = json_schema.get("oneOf")
+    if _is_list(one_of):
+        existing_any_of = json_schema.get("anyOf", [])
+        if not _is_list(existing_any_of):
+            existing_any_of = []
+        json_schema["anyOf"] = existing_any_of + [
+            _ensure_strict_json_schema(variant, path=(*path, "oneOf", str(i)), root=root)
+            for i, variant in enumerate(one_of)
+        ]
+        json_schema.pop("oneOf")
+
+    all_of = json_schema.get("allOf")
+    if _is_list(all_of):
+        if len(all_of) == 1:
+            json_schema.update(
+                _ensure_strict_json_schema(all_of[0], path=(*path, "allOf", "0"), root=root)
+            )
+            json_schema.pop("allOf")
+        else:
+            json_schema["allOf"] = [
+                _ensure_strict_json_schema(entry, path=(*path, "allOf", str(i)), root=root)
+                for i, entry in enumerate(all_of)
+            ]
+
+    if "default" in json_schema:
+        json_schema.pop("default")
+
+    for keyword in ("title", "examples"):
+        json_schema.pop(keyword, None)
+
+    ref = json_schema.get("$ref")
+    if ref and _has_more_than_n_keys(json_schema, 1):
+        if not isinstance(ref, str):
+            raise ValueError(f"Received non-string $ref - {ref}")
+        resolved = _resolve_ref(root=root, ref=ref)
+        if not _is_dict(resolved):
+            raise ValueError(
+                f"Expected `$ref: {ref}` to resolve to a dictionary but got {resolved}"
+            )
+        json_schema.update({**resolved, **json_schema})
+        json_schema.pop("$ref")
+        return _ensure_strict_json_schema(json_schema, path=path, root=root)
+
+    return json_schema
+
+
+def _resolve_ref(*, root: dict[str, Any], ref: str) -> object:
+    if not ref.startswith("#/"):
+        raise ValueError(f"Unexpected $ref format {ref!r}; does not start with #/")
+
+    path = ref[2:].split("/")
+    resolved: object = root
+    for key in path:
+        assert _is_dict(resolved), f"Encountered non-dictionary entry while resolving {ref}"
+        resolved = resolved[key]
+
+    return resolved
+
+
+def _is_dict(obj: object) -> TypeGuard[dict[str, Any]]:
+    return isinstance(obj, dict)
+
+
+def _is_list(obj: object) -> TypeGuard[list[object]]:
+    return isinstance(obj, list)
+
+
+def _has_more_than_n_keys(obj: dict[str, object], n: int) -> bool:
+    return any(count > n for count, _ in enumerate(obj, start=1))

hud/utils/tests/test_init.py

@@ -11,7 +11,6 @@ def test_utils_imports():
     assert hud.utils is not None
 
     # Try importing submodules
-    from hud.utils import progress, telemetry
+    from hud.utils import telemetry
 
-    assert progress is not None
     assert telemetry is not None

hud/utils/tests/test_mcp.py

@@ -2,9 +2,7 @@
 
 from __future__ import annotations
 
-import pytest
-
-from hud.utils.mcp import MCPConfigPatch, patch_mcp_config, setup_hud_telemetry
+from hud.utils.mcp import MCPConfigPatch, patch_mcp_config
 
 
 class TestPatchMCPConfig:
@@ -85,28 +83,3 @@ class TestPatchMCPConfig:
         # Existing meta should be preserved, new one added
         assert mcp_config["test_server"]["meta"]["existing_key"] == "existing_value"
         assert mcp_config["test_server"]["meta"]["test_key"] == "test_value"
-
-
-class TestSetupHUDTelemetry:
-    """Tests for setup_hud_telemetry function."""
-
-    def test_empty_config_raises_error(self):
-        """Test that empty config raises ValueError."""
-        with pytest.raises(
-            ValueError, match="Please run initialize\\(\\) before setting up client-side telemetry"
-        ):
-            setup_hud_telemetry({})
-
-    def test_none_config_raises_error(self):
-        """Test that None config raises ValueError."""
-        with pytest.raises(
-            ValueError, match="Please run initialize\\(\\) before setting up client-side telemetry"
-        ):
-            setup_hud_telemetry(None)  # type: ignore[arg-type]
-
-    def test_valid_config_returns_none_when_no_hud_servers(self):
-        """Test that valid config with no HUD servers returns None."""
-        mcp_config = {"test_server": {"url": "http://example.com"}}
-
-        result = setup_hud_telemetry(mcp_config)
-        assert result is None

hud/utils/tests/test_pretty_errors.py

@@ -0,0 +1,186 @@
+from __future__ import annotations
+
+import sys
+from unittest.mock import MagicMock, patch
+
+from hud.utils.pretty_errors import (
+    _async_exception_handler,
+    _render_and_fallback,
+    install_pretty_errors,
+)
+
+
+def test_render_and_fallback_hud_exception():
+    """Test _render_and_fallback with HudException."""
+    from hud.shared.exceptions import HudException
+
+    exc = HudException("Test error")
+
+    with (
+        patch("sys.__excepthook__") as mock_excepthook,
+        patch("hud.utils.pretty_errors.hud_console") as mock_console,
+        patch("sys.stderr.flush"),
+    ):
+        _render_and_fallback(HudException, exc, None)
+
+        mock_excepthook.assert_called_once()
+        mock_console.render_exception.assert_called_once_with(exc)
+
+
+def test_render_and_fallback_non_hud_exception():
+    """Test _render_and_fallback with non-HudException."""
+    exc = ValueError("Test error")
+
+    with (
+        patch("sys.__excepthook__") as mock_excepthook,
+        patch("hud.utils.pretty_errors.hud_console") as mock_console,
+    ):
+        _render_and_fallback(ValueError, exc, None)
+
+        mock_excepthook.assert_called_once()
+        # Should not render for non-HudException
+        mock_console.render_exception.assert_not_called()
+
+
+def test_render_and_fallback_rendering_error():
+    """Test _render_and_fallback handles rendering errors gracefully."""
+    from hud.shared.exceptions import HudException
+
+    exc = HudException("Test error")
+
+    with (
+        patch("sys.__excepthook__") as mock_excepthook,
+        patch("hud.utils.pretty_errors.hud_console") as mock_console,
+    ):
+        mock_console.render_exception.side_effect = Exception("Render failed")
+
+        # Should not raise
+        _render_and_fallback(HudException, exc, None)
+
+        mock_excepthook.assert_called_once()
+
+
+def test_async_exception_handler_with_exception():
+    """Test _async_exception_handler with exception in context."""
+    mock_loop = MagicMock()
+    context = {"exception": ValueError("Test error")}
+
+    with patch("hud.utils.pretty_errors.hud_console") as mock_console:
+        _async_exception_handler(mock_loop, context)
+
+        mock_console.render_exception.assert_called_once()
+        mock_loop.default_exception_handler.assert_called_once_with(context)
+
+
+def test_async_exception_handler_with_message():
+    """Test _async_exception_handler with message only."""
+    mock_loop = MagicMock()
+    context = {"message": "Error message"}
+
+    with patch("hud.utils.pretty_errors.hud_console") as mock_console:
+        _async_exception_handler(mock_loop, context)
+
+        mock_console.error.assert_called_once_with("Error message")
+        mock_console.render_support_hint.assert_called_once()
+        mock_loop.default_exception_handler.assert_called_once()
+
+
+def test_async_exception_handler_rendering_error():
+    """Test _async_exception_handler handles rendering errors."""
+    mock_loop = MagicMock()
+    context = {"exception": ValueError("Test")}
+
+    with patch("hud.utils.pretty_errors.hud_console") as mock_console:
+        mock_console.render_exception.side_effect = Exception("Render failed")
+
+        # Should not raise, should call default handler
+        _async_exception_handler(mock_loop, context)
+
+        mock_loop.default_exception_handler.assert_called_once()
+
+
+def test_install_pretty_errors_with_running_loop():
+    """Test install_pretty_errors with a running event loop."""
+    mock_loop = MagicMock()
+
+    with patch("asyncio.get_running_loop", return_value=mock_loop):
+        install_pretty_errors()
+
+        assert sys.excepthook == _render_and_fallback
+        mock_loop.set_exception_handler.assert_called_once_with(_async_exception_handler)
+
+
+def test_install_pretty_errors_no_running_loop():
+    """Test install_pretty_errors without a running loop."""
+    with (
+        patch("asyncio.get_running_loop", side_effect=RuntimeError("No running loop")),
+        patch("asyncio.new_event_loop") as mock_new_loop,
+    ):
+        mock_loop = MagicMock()
+        mock_new_loop.return_value = mock_loop
+
+        install_pretty_errors()
+
+        assert sys.excepthook == _render_and_fallback
+        mock_loop.set_exception_handler.assert_called_once()
+
+
+def test_install_pretty_errors_new_loop_fails():
+    """Test install_pretty_errors when creating new loop fails."""
+    with (
+        patch("asyncio.get_running_loop", side_effect=RuntimeError("No running loop")),
+        patch("asyncio.new_event_loop", side_effect=Exception("Can't create loop")),
+    ):
+        # Should not raise
+        install_pretty_errors()
+
+        assert sys.excepthook == _render_and_fallback
+
+
+def test_install_pretty_errors_set_handler_fails():
+    """Test install_pretty_errors when set_exception_handler fails."""
+    mock_loop = MagicMock()
+    mock_loop.set_exception_handler.side_effect = Exception("Can't set handler")
+
+    with patch("asyncio.get_running_loop", return_value=mock_loop):
+        # Should not raise
+        install_pretty_errors()
+
+        assert sys.excepthook == _render_and_fallback
+
+
+def test_async_exception_handler_no_exception_or_message():
+    """Test _async_exception_handler with empty context."""
+    mock_loop = MagicMock()
+    context = {}
+
+    with patch("hud.utils.pretty_errors.hud_console") as mock_console:
+        _async_exception_handler(mock_loop, context)
+
+        mock_console.render_exception.assert_not_called()
+        mock_console.error.assert_not_called()
+        mock_loop.default_exception_handler.assert_called_once()
+
+
+def test_render_and_fallback_with_traceback():
+    """Test _render_and_fallback includes traceback."""
+    from hud.shared.exceptions import HudException
+
+    exc = HudException("Test error")
+
+    # Create a fake traceback
+    try:
+        raise exc
+    except HudException as e:
+        tb = e.__traceback__
+
+    with (
+        patch("sys.__excepthook__") as mock_excepthook,
+        patch("hud.utils.pretty_errors.hud_console"),
+        patch("sys.stderr.flush"),
+    ):
+        _render_and_fallback(HudException, exc, tb)
+
+        # Should call excepthook with traceback
+        call_args = mock_excepthook.call_args[0]
+        assert call_args[2] == tb