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

hud/utils/hud_console.py

@@ -20,9 +20,8 @@ import time
 import traceback
 from typing import TYPE_CHECKING, Any, Literal, Self
 
-import questionary
-import typer
 from rich.console import Console
+from rich.markup import escape
 from rich.panel import Panel
 from rich.table import Table
 
@@ -38,9 +37,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.
 
@@ -80,7 +96,7 @@ class HUDConsole:
             stderr: If True, output to stderr (default), otherwise stdout
         """
         console = self._stderr_console if stderr else self._stdout_console
-        console.print(f"[{GREEN}]✅ {message}[/{GREEN}]")
+        console.print(f"[{GREEN}]✅ {escape(message)}[/{GREEN}]")
 
     def error(self, message: str, stderr: bool = True) -> None:
         """Print an error message.
@@ -91,10 +107,12 @@ class HUDConsole:
         """
         console = self._stderr_console if stderr else self._stdout_console
         tb = traceback.format_exc()
+        escaped_message = escape(message)
         if "NoneType: None" not in tb:
-            console.print(f"[{RED} not bold]❌ {message}\n{tb}[/{RED} not bold]")
+            escaped_tb = escape(tb)
+            console.print(f"[{RED} not bold]❌ {escaped_message}\n{escaped_tb}[/{RED} not bold]")
         else:
-            console.print(f"[{RED} not bold]❌ {message}[/{RED} not bold]")
+            console.print(f"[{RED} not bold]❌ {escaped_message}[/{RED} not bold]")
 
     def warning(self, message: str, stderr: bool = True) -> None:
         """Print a warning message.
@@ -104,7 +122,7 @@ class HUDConsole:
             stderr: If True, output to stderr (default), otherwise stdout
         """
         console = self._stderr_console if stderr else self._stdout_console
-        console.print(f"⚠️  [{YELLOW} not bold]{message}[/{YELLOW} not bold]")
+        console.print(f"⚠️  [{YELLOW} not bold]{escape(message)}[/{YELLOW} not bold]")
 
     def info(self, message: str, stderr: bool = True) -> None:
         """Print an info message.
@@ -114,7 +132,7 @@ class HUDConsole:
             stderr: If True, output to stderr (default), otherwise stdout
         """
         console = self._stderr_console if stderr else self._stdout_console
-        console.print(f"[{TEXT} not bold]{message}[/{TEXT} not bold]")
+        console.print(f"[{TEXT} not bold]{escape(message)}[/{TEXT} not bold]")
 
     def print(self, message: str, stderr: bool = True) -> None:
         """Print a message.
@@ -136,7 +154,7 @@ class HUDConsole:
         """
         console = self._stderr_console if stderr else self._stdout_console
         console.print(
-            f"[{DIM} not bold][default]{label}[/default][/{DIM} not bold] [default]{value}[/default]"  # noqa: E501
+            f"[{DIM} not bold][default]{escape(label)}[/default][/{DIM} not bold] [default]{escape(value)}[/default]"  # noqa: E501
         )
 
     def link(self, url: str, stderr: bool = True) -> None:
@@ -147,7 +165,7 @@ class HUDConsole:
             stderr: If True, output to stderr (default), otherwise stdout
         """
         console = self._stderr_console if stderr else self._stdout_console
-        console.print(f"[{SECONDARY} underline]{url}[/{SECONDARY} underline]")
+        console.print(f"[{SECONDARY} underline]{escape(url)}[/{SECONDARY} underline]")
 
     def json_config(self, json_str: str, stderr: bool = True) -> None:
         """Print JSON configuration with neutral theme.
@@ -158,7 +176,7 @@ class HUDConsole:
         """
         # Print JSON with neutral grey text
         console = self._stderr_console if stderr else self._stdout_console
-        console.print(f"[{TEXT}]{json_str}[/{TEXT}]")
+        console.print(f"[{TEXT}]{escape(json_str)}[/{TEXT}]")
 
     def key_value_table(
         self, data: dict[str, str | int | float], show_header: bool = False, stderr: bool = True
@@ -188,7 +206,7 @@ class HUDConsole:
             stderr: If True, output to stderr (default), otherwise stdout
         """
         console = self._stderr_console if stderr else self._stdout_console
-        console.print(f"[{DIM}]{message}[/{DIM}]")
+        console.print(f"[{DIM}]{escape(message)}[/{DIM}]")
 
     def phase(self, phase_num: int, title: str, stderr: bool = True) -> None:
         """Print a phase header (for debug command).
@@ -221,7 +239,7 @@ class HUDConsole:
             stderr: If True, output to stderr (default), otherwise stdout
         """
         console = self._stderr_console if stderr else self._stdout_console
-        console.print(f"[rgb(181,137,0)]💡 Hint: {hint}[/rgb(181,137,0)]")
+        console.print(f"[rgb(181,137,0)]💡 Hint: {escape(hint)}[/rgb(181,137,0)]")
 
     def status_item(
         self,
@@ -250,10 +268,14 @@ class HUDConsole:
         indicator = indicators.get(status, indicators["info"])
         console = self._stderr_console if stderr else self._stdout_console
 
+        escaped_label = escape(label)
+        escaped_value = escape(value)
         if primary:
-            console.print(f"{indicator} {label}: [bold {SECONDARY}]{value}[/bold {SECONDARY}]")
+            console.print(
+                f"{indicator} {escaped_label}: [bold {SECONDARY}]{escaped_value}[/bold {SECONDARY}]"
+            )
         else:
-            console.print(f"{indicator} {label}: [{TEXT}]{value}[/{TEXT}]")
+            console.print(f"{indicator} {escaped_label}: [{TEXT}]{escaped_value}[/{TEXT}]")
 
     def command_example(
         self, command: str, description: str | None = None, stderr: bool = True
@@ -470,6 +492,9 @@ class HUDConsole:
         Returns:
             The selected choice value
         """
+        import questionary
+        from questionary import Style
+
         # Convert choices to questionary format
         q_choices = []
 
@@ -481,15 +506,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
@@ -516,7 +553,12 @@ class HUDConsole:
             except (TypeError, ValueError):
                 args_str = str(arguments)[:60]
 
-        return f"[{GOLD}]→[/{GOLD}] [bold {TEXT}]{name}[/bold {TEXT}][{DIM}]({args_str})[/{DIM}]"
+        escaped_name = escape(name)
+        escaped_args = escape(args_str)
+        return (
+            f"[{GOLD}]→[/{GOLD}] [bold {TEXT}]{escaped_name}[/bold {TEXT}]"
+            f"[{DIM}]({escaped_args})[/{DIM}]"
+        )
 
     def format_tool_result(self, content: str, is_error: bool = False) -> str:
         """Format a tool result in compact HUD style.
@@ -532,11 +574,12 @@ class HUDConsole:
         if len(content) > 80:
             content = content[:77] + "..."
 
+        escaped_content = escape(content)
         # Format with status using HUD colors
         if is_error:
-            return f"  [{RED}]✗[/{RED}] [{DIM}]{content}[/{DIM}]"
+            return f"  [{RED}]✗[/{RED}] [{DIM}]{escaped_content}[/{DIM}]"
         else:
-            return f"  [{GREEN}]✓[/{GREEN}] [{TEXT}]{content}[/{TEXT}]"
+            return f"  [{GREEN}]✓[/{GREEN}] [{TEXT}]{escaped_content}[/{TEXT}]"
 
     def confirm(self, message: str, default: bool = True) -> bool:
         """Print a confirmation message.
@@ -545,8 +588,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}] {escape(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}] {escape(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", "format"):
+        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