hud-python 0.4.22__tar.gz → 0.4.23__tar.gz

{hud_python-0.4.22 → hud_python-0.4.23}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hud-python
-Version: 0.4.22
+Version: 0.4.23
 Summary: SDK for the HUD platform.
 Project-URL: Homepage, https://github.com/hud-evals/hud-python
 Project-URL: Bug Tracker, https://github.com/hud-evals/hud-python/issues
@@ -66,6 +66,7 @@ Requires-Dist: langchain-anthropic; extra == 'agent'
 Requires-Dist: langchain-openai; extra == 'agent'
 Requires-Dist: numpy>=1.24.0; extra == 'agent'
 Requires-Dist: openai; extra == 'agent'
+Requires-Dist: pillow>=11.1.0; extra == 'agent'
 Provides-Extra: agents
 Requires-Dist: anthropic; extra == 'agents'
 Requires-Dist: datasets>=2.14.0; extra == 'agents'
@@ -79,6 +80,7 @@ Requires-Dist: langchain-anthropic; extra == 'agents'
 Requires-Dist: langchain-openai; extra == 'agents'
 Requires-Dist: numpy>=1.24.0; extra == 'agents'
 Requires-Dist: openai; extra == 'agents'
+Requires-Dist: pillow>=11.1.0; extra == 'agents'
 Provides-Extra: dev
 Requires-Dist: aiodocker>=0.24.0; extra == 'dev'
 Requires-Dist: anthropic; extra == 'dev'

{hud_python-0.4.22 → hud_python-0.4.23}/hud/agents/base.py

@@ -11,7 +11,7 @@ from typing import TYPE_CHECKING, Any, ClassVar, Literal
 import mcp.types as types
 
 from hud.types import AgentResponse, MCPToolCall, MCPToolResult, Trace
-from hud.utils.design import HUDDesign
+from hud.utils.hud_console import HUDConsole
 from hud.utils.mcp import MCPConfigPatch, patch_mcp_config, setup_hud_telemetry
 
 if TYPE_CHECKING:
@@ -37,7 +37,7 @@ class MCPAgent(ABC):
       and automatic marking of lifecycle tools (setup/evaluate) from a `Task`.
     - Messaging: system prompt handling, optional inclusion of setup output on
       the first turn, and control over initial screenshots.
-    - Telemetry & UX: standardized logging/printing via `HUDDesign` and optional
+    - Telemetry & UX: standardized logging/printing via `HUDConsole` and optional
       automatic tracing (`auto_trace`).
 
     Subclasses implement provider-specific formatting and response fetching
@@ -92,13 +92,11 @@ class MCPAgent(ABC):
         self._auto_created_client = False  # Track if we created the client
 
         self.model_name = model_name
-        self.design = HUDDesign(logger=logger)
-
-        self.metadata = {}
+        self.console = HUDConsole(logger=logger)
 
         # Set verbose mode if requested
         if verbose:
-            self.design.set_verbose(True)
+            self.console.set_verbose(True)
 
         # Filtering
         self.allowed_tools = allowed_tools
@@ -133,7 +131,7 @@ class MCPAgent(ABC):
 
             self.mcp_client = MCPClient(mcp_config=task.mcp_config)
             self._auto_created_client = True
-            self.design.info_log("Auto-created MCPClient from task.mcp_config")
+            self.console.info_log("Auto-created MCPClient from task.mcp_config")
 
         # Ensure we have a client
         if self.mcp_client is None:
@@ -170,7 +168,7 @@ class MCPAgent(ABC):
         await self._filter_tools()
 
         num_tools = len(self._available_tools)
-        self.design.success_log(
+        self.console.success_log(
             f"Agent initialized with {num_tools} available tools (after filtering)"
         )
 
@@ -245,7 +243,7 @@ class MCPAgent(ABC):
 
             # Execute the setup tool and append the initial observation to the context
             if task.setup_tool is not None:
-                self.design.progress_log(f"Setting up tool phase: {task.setup_tool}")
+                self.console.progress_log(f"Setting up tool phase: {task.setup_tool}")
                 results = await self.call_tools(task.setup_tool)
                 if any(result.isError for result in results):
                     raise RuntimeError(f"{results}")
@@ -259,7 +257,7 @@ class MCPAgent(ABC):
             prompt_result = await self._run_context(start_context, max_steps=max_steps)
 
         except Exception as e:
-            self.design.error_log(f"Task execution failed: {e}")
+            self.console.error_log(f"Task execution failed: {e}")
             # Create an error result but don't return yet - we still want to evaluate
             prompt_result = Trace(reward=0.0, done=True, content=str(e), isError=True)
             prompt_result.populate_from_context()
@@ -267,7 +265,7 @@ class MCPAgent(ABC):
         # Always evaluate if we have a prompt result and evaluate tool
         if prompt_result is not None and task.evaluate_tool is not None:
             try:
-                self.design.progress_log(f"Evaluating tool phase: {task.evaluate_tool}")
+                self.console.progress_log(f"Evaluating tool phase: {task.evaluate_tool}")
                 results = await self.call_tools(task.evaluate_tool)
 
                 if any(result.isError for result in results):
@@ -290,7 +288,7 @@ class MCPAgent(ABC):
                             prompt_result.content = eval_content
 
             except Exception as e:
-                self.design.error_log(f"Evaluation phase failed: {e}")
+                self.console.error_log(f"Evaluation phase failed: {e}")
                 # Continue with the prompt result even if evaluation failed
 
         return (
@@ -321,21 +319,21 @@ class MCPAgent(ABC):
 
             # Add initial context
             messages.extend(await self.format_message(context))
-            self.design.debug(f"Messages: {messages}")
+            self.console.debug(f"Messages: {messages}")
 
             step_count = 0
             while max_steps == -1 or step_count < max_steps:
                 step_count += 1
                 if max_steps == -1:
-                    self.design.debug(f"Step {step_count} (unlimited)")
+                    self.console.debug(f"Step {step_count} (unlimited)")
                 else:
-                    self.design.debug(f"Step {step_count}/{max_steps}")
+                    self.console.debug(f"Step {step_count}/{max_steps}")
 
                 try:
                     # 1. Get model response
                     response = await self.get_response(messages)
 
-                    self.design.debug(f"Agent:\n{response}")
+                    self.console.debug(f"Agent:\n{response}")
 
                     # Check if we should stop
                     if response.done or not response.tool_calls:
@@ -347,16 +345,16 @@ class MCPAgent(ABC):
                                     response.content
                                 )
                             except Exception as e:
-                                self.design.warning_log(f"ResponseAgent failed: {e}")
+                                self.console.warning_log(f"ResponseAgent failed: {e}")
                         if decision == "STOP":
                             # Try to submit response through lifecycle tool
                             await self._maybe_submit_response(response, messages)
 
-                            self.design.debug("Stopping execution")
+                            self.console.debug("Stopping execution")
                             final_response = response
                             break
                         else:
-                            self.design.debug("Continuing execution")
+                            self.console.debug("Continuing execution")
                             messages.extend(await self.format_message(decision))
                             continue
 
@@ -378,21 +376,21 @@ class MCPAgent(ABC):
                     for call, result in zip(tool_calls, tool_results, strict=False):
                         step_info += f"\n{call}\n{result}"
 
-                    self.design.info_log(step_info)
+                    self.console.info_log(step_info)
 
                 except Exception as e:
-                    self.design.error_log(f"Step failed: {e}")
+                    self.console.error_log(f"Step failed: {e}")
                     error = str(e)
                     break
 
         except KeyboardInterrupt:
-            self.design.warning_log("Agent execution interrupted by user")
+            self.console.warning_log("Agent execution interrupted by user")
             error = "Interrupted by user"
         except asyncio.CancelledError:
-            self.design.warning_log("Agent execution cancelled")
+            self.console.warning_log("Agent execution cancelled")
             error = "Cancelled"
         except Exception as e:
-            self.design.error_log(f"Unexpected error: {e}")
+            self.console.error_log(f"Unexpected error: {e}")
             error = str(e)
 
         # Build result
@@ -433,17 +431,17 @@ class MCPAgent(ABC):
         results: list[MCPToolResult] = []
         for tc in tool_call:
             try:
-                self.design.debug(f"Calling tool: {tc}")
+                self.console.debug(f"Calling tool: {tc}")
                 results.append(await self.mcp_client.call_tool(tc))
             except TimeoutError as e:
-                self.design.error_log(f"Tool execution timed out: {e}")
+                self.console.error_log(f"Tool execution timed out: {e}")
                 try:
                     await self.mcp_client.shutdown()
                 except Exception as close_err:
-                    self.design.debug(f"Failed to close MCP client cleanly: {close_err}")
+                    self.console.debug(f"Failed to close MCP client cleanly: {close_err}")
                 raise
             except Exception as e:
-                self.design.error_log(f"Tool execution failed: {e}")
+                self.console.error_log(f"Tool execution failed: {e}")
                 results.append(_format_error_result(str(e)))
         return results
 
@@ -575,7 +573,7 @@ class MCPAgent(ABC):
 
             # Add to lifecycle tools if found
             if response_tool_name and response_tool_name not in self.lifecycle_tools:
-                self.design.debug(f"Auto-detected '{response_tool_name}' tool as a lifecycle tool")
+                self.console.debug(f"Auto-detected '{response_tool_name}' tool as a lifecycle tool")
                 self.response_tool_name = response_tool_name
                 self.lifecycle_tools.append(response_tool_name)
 
@@ -599,7 +597,7 @@ class MCPAgent(ABC):
             messages: The current message history (will be modified in-place)
         """
         if self.response_tool_name:
-            self.design.debug(f"Calling response lifecycle tool: {self.response_tool_name}")
+            self.console.debug(f"Calling response lifecycle tool: {self.response_tool_name}")
             try:
                 # Call the response tool with the agent's response
                 response_tool_call = MCPToolCall(
@@ -614,9 +612,9 @@ class MCPAgent(ABC):
                 messages.extend(response_messages)
 
                 # Mark the task as done
-                self.design.debug("Response lifecycle tool executed, marking task as done")
+                self.console.debug("Response lifecycle tool executed, marking task as done")
             except Exception as e:
-                self.design.error_log(f"Response lifecycle tool failed: {e}")
+                self.console.error_log(f"Response lifecycle tool failed: {e}")
 
     async def _setup_config(self, mcp_config: dict[str, dict[str, Any]]) -> None:
         """Inject metadata into the metadata of the initialize request."""
@@ -670,9 +668,9 @@ class MCPAgent(ABC):
         if self._auto_trace_cm:
             try:
                 self._auto_trace_cm.__exit__(None, None, None)
-                self.design.debug("Closed auto-created trace")
+                self.console.debug("Closed auto-created trace")
             except Exception as e:
-                self.design.warning_log(f"Failed to close auto-created trace: {e}")
+                self.console.warning_log(f"Failed to close auto-created trace: {e}")
             finally:
                 self._auto_trace_cm = None
 
@@ -680,9 +678,9 @@ class MCPAgent(ABC):
         if self._auto_created_client and self.mcp_client:
             try:
                 await self.mcp_client.shutdown()
-                self.design.debug("Closed auto-created MCPClient")
+                self.console.debug("Closed auto-created MCPClient")
             except Exception as e:
-                self.design.warning_log(f"Failed to close auto-created client: {e}")
+                self.console.warning_log(f"Failed to close auto-created client: {e}")
             finally:
                 self.mcp_client = None
                 self._auto_created_client = False
@@ -715,13 +713,13 @@ class MCPAgent(ABC):
         if self._is_connection_error(e):
             msg = self._get_connection_error_message(e)
             # Always show connection errors, not just when logging is enabled
-            self.design.error(f"❌ {msg}")
-            self.design.info("💡 Make sure the MCP server is started before running the agent.")
+            self.console.error(f"❌ {msg}")
+            self.console.info("💡 Make sure the MCP server is started before running the agent.")
 
             # For localhost, provide specific instructions
             error_str = str(e).lower()
             if "localhost" in error_str or "127.0.0.1" in error_str:
-                self.design.info("   Run 'hud dev' in another terminal to start the MCP server")
+                self.console.info("   Run 'hud dev' in another terminal to start the MCP server")
 
             raise RuntimeError(msg) from e
         raise

{hud_python-0.4.22 → hud_python-0.4.23}/hud/agents/grounded_openai.py

@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 import json
-from typing import Any
+from typing import Any, ClassVar
 
 from hud import instrument
 from hud.tools.grounding import GroundedComputerTool, Grounder, GrounderConfig
@@ -26,6 +26,8 @@ class GroundedOpenAIChatAgent(GenericOpenAIChatAgent):
     - Grounding model (Qwen2-VL etc) handles visual element detection
     """
 
+    metadata: ClassVar[dict[str, Any]] = {}
+
     def __init__(
         self,
         *,

{hud_python-0.4.22 → hud_python-0.4.23}/hud/agents/misc/response_agent.py

@@ -16,7 +16,7 @@ class ResponseAgent:
     based on the agent's final response message.
     """
 
-    def __init__(self, api_key: str | None = None) -> None:
+    def __init__(self, api_key: str | None = None, model: str = "gpt-4o") -> None:
         self.api_key = api_key or settings.openai_api_key or os.environ.get("OPENAI_API_KEY")
         if not self.api_key:
             raise ValueError(
@@ -24,6 +24,7 @@ class ResponseAgent:
             )
 
         self.client = AsyncOpenAI(api_key=self.api_key)
+        self.model = model
 
         self.system_prompt = """
         You are an assistant that helps determine the appropriate response to an agent's message.
@@ -54,7 +55,7 @@ class ResponseAgent:
         """
         try:
             response = await self.client.chat.completions.create(
-                model="gpt-5-nano",
+                model=self.model,
                 messages=[
                     {"role": "system", "content": self.system_prompt},
                     {

{hud_python-0.4.22 → hud_python-0.4.23}/hud/agents/openai.py

@@ -204,7 +204,7 @@ class OperatorAgent(MCPAgent):
                         break
 
                 if not latest_screenshot:
-                    self.design.warning_log("No screenshot provided for response to action")
+                    self.console.warning_log("No screenshot provided for response to action")
                     return AgentResponse(
                         content="No screenshot available for next action",
                         tool_calls=[],
@@ -327,7 +327,7 @@ class OperatorAgent(MCPAgent):
                 for content in result.content:
                     if isinstance(content, types.TextContent):
                         # Don't add error text as input_text, just track it
-                        self.design.error_log(f"Tool error: {content.text}")
+                        self.console.error_log(f"Tool error: {content.text}")
                     elif isinstance(content, types.ImageContent):
                         # Even error results might have images
                         latest_screenshot = content.data

{hud_python-0.4.22 → hud_python-0.4.23}/hud/agents/openai_chat_generic.py

@@ -17,7 +17,7 @@ from __future__ import annotations
 
 import json
 import logging
-from typing import TYPE_CHECKING, Any, cast
+from typing import TYPE_CHECKING, Any, ClassVar, cast
 
 import mcp.types as types
 
@@ -36,6 +36,8 @@ logger = logging.getLogger(__name__)
 class GenericOpenAIChatAgent(MCPAgent):
     """MCP-enabled agent that speaks the OpenAI *chat.completions* protocol."""
 
+    metadata: ClassVar[dict[str, Any]] = {}
+
     def __init__(
         self,
         *,

{hud_python-0.4.22 → hud_python-0.4.23}/hud/cli/__init__.py

@@ -184,7 +184,7 @@ def debug(
         hud debug . --max-phase 3               # Stop after phase 3
     """
     # Import here to avoid circular imports
-    from hud.utils.design import HUDDesign
+    from hud.utils.hud_console import HUDConsole
 
     from .utils.environment import (
         build_environment,
@@ -193,7 +193,7 @@ def debug(
         is_environment_directory,
     )
 
-    design = HUDDesign()
+    hud_console = HUDConsole()
 
     # Determine the command to run
     command = None
@@ -227,7 +227,7 @@ def debug(
             image_name, source = get_image_name(directory)
 
             if source == "auto":
-                design.info(f"Auto-generated image name: {image_name}")
+                hud_console.info(f"Auto-generated image name: {image_name}")
 
             # Build if requested or if image doesn't exist
             if build or not image_exists(image_name):
@@ -263,20 +263,20 @@ def debug(
     phases_completed = asyncio.run(debug_mcp_stdio(command, logger, max_phase=max_phase))
 
     # Show summary using design system
-    from hud.utils.design import HUDDesign
+    from hud.utils.hud_console import HUDConsole
 
-    design = HUDDesign()
+    hud_console = HUDConsole()
 
-    design.info("")  # Empty line
-    design.section_title("Debug Summary")
+    hud_console.info("")  # Empty line
+    hud_console.section_title("Debug Summary")
 
     if phases_completed == max_phase:
-        design.success(f"All {max_phase} phases completed successfully!")
+        hud_console.success(f"All {max_phase} phases completed successfully!")
         if max_phase == 5:
-            design.info("Your MCP server is fully functional and ready for production use.")
+            hud_console.info("Your MCP server is fully functional and ready for production use.")
     else:
-        design.warning(f"Completed {phases_completed} out of {max_phase} phases")
-        design.info("Check the errors above for troubleshooting.")
+        hud_console.warning(f"Completed {phases_completed} out of {max_phase} phases")
+        hud_console.info("Check the errors above for troubleshooting.")
 
     # Exit with appropriate code
     if phases_completed < max_phase:
@@ -831,9 +831,9 @@ def eval(
     ),
 ) -> None:
     """🚀 Run evaluation on datasets or individual tasks with agents."""
-    from hud.utils.design import HUDDesign
+    from hud.utils.hud_console import HUDConsole
 
-    design = HUDDesign()
+    hud_console = HUDConsole()
 
     # If no source provided, look for task/eval JSON files in current directory
     if source is None:
@@ -863,30 +863,30 @@ def eval(
         json_files = sorted(set(json_files))
 
         if not json_files:
-            design.error(
+            hud_console.error(
                 "No source provided and no task/eval JSON files found in current directory"
             )
-            design.info(
+            hud_console.info(
                 "Usage: hud eval <source> or create a task JSON file "
                 "(e.g., task.json, eval_config.json)"
             )
             raise typer.Exit(1)
         elif len(json_files) == 1:
             source = str(json_files[0])
-            design.info(f"Found task file: {source}")
+            hud_console.info(f"Found task file: {source}")
         else:
             # Multiple files found, let user choose
-            design.info("Multiple task files found:")
-            file_choice = design.select(
+            hud_console.info("Multiple task files found:")
+            file_choice = hud_console.select(
                 "Select a task file to run:",
                 choices=[str(f) for f in json_files],
             )
             source = file_choice
-            design.success(f"Selected: {source}")
+            hud_console.success(f"Selected: {source}")
 
     # If no agent specified, prompt for selection
     if agent is None:
-        agent = design.select(
+        agent = hud_console.select(
             "Select an agent to use:",
             choices=[
                 {"name": "Claude 4 Sonnet", "value": "claude"},
@@ -898,14 +898,14 @@ def eval(
     # Validate agent choice
     valid_agents = ["claude", "openai"]
     if agent not in valid_agents:
-        design.error(f"Invalid agent: {agent}. Must be one of: {', '.join(valid_agents)}")
+        hud_console.error(f"Invalid agent: {agent}. Must be one of: {', '.join(valid_agents)}")
         raise typer.Exit(1)
 
     # Import eval_command lazily to avoid importing agent dependencies
     try:
         from .eval import eval_command
     except ImportError as e:
-        design.error(
+        hud_console.error(
             "Evaluation dependencies are not installed. "
             "Please install with: pip install 'hud-python[agent]'"
         )
@@ -962,6 +962,16 @@ def hf(
 
 def main() -> None:
     """Main entry point for the CLI."""
+    # Handle --version flag before Typer parses args
+    if "--version" in sys.argv:
+        try:
+            from hud import __version__
+
+            console.print(f"HUD CLI version: [cyan]{__version__}[/cyan]")
+        except ImportError:
+            console.print("HUD CLI version: [cyan]unknown[/cyan]")
+        return
+
     try:
         # Show header for main help
         if len(sys.argv) == 1 or (len(sys.argv) == 2 and sys.argv[1] in ["--help", "-h"]):
@@ -995,9 +1005,9 @@ def main() -> None:
         except Exception:
             exit_code = 1
         if exit_code != 0:
-            from hud.utils.design import design
+            from hud.utils.hud_console import hud_console
 
-            design.info(SUPPORT_HINT)
+            hud_console.info(SUPPORT_HINT)
         raise
     except Exception:
         raise

{hud_python-0.4.22 → hud_python-0.4.23}/hud/cli/analyze.py

@@ -13,10 +13,10 @@ from rich.table import Table
 from rich.tree import Tree
 
 from hud.clients import MCPClient
-from hud.utils.design import HUDDesign
+from hud.utils.hud_console import HUDConsole
 
 console = Console()
-design = HUDDesign()
+hud_console = HUDConsole()
 
 
 def parse_docker_command(docker_cmd: list[str]) -> dict:
@@ -28,14 +28,14 @@ def parse_docker_command(docker_cmd: list[str]) -> dict:
 
 async def analyze_environment(docker_cmd: list[str], output_format: str, verbose: bool) -> None:
     """Analyze MCP environment and display results."""
-    design.header("MCP Environment Analysis", icon="🔍")
+    hud_console.header("MCP Environment Analysis", icon="🔍")
 
     # Convert Docker command to MCP config
     mcp_config = parse_docker_command(docker_cmd)
 
     # Display command being analyzed
-    design.dim_info("Command:", " ".join(docker_cmd))
-    design.info("")  # Empty line
+    hud_console.dim_info("Command:", " ".join(docker_cmd))
+    hud_console.info("")  # Empty line
 
     # Create client
     with Progress(
@@ -85,9 +85,9 @@ async def analyze_environment(docker_cmd: list[str], output_format: str, verbose
 def display_interactive(analysis: dict) -> None:
     """Display analysis results in interactive format."""
     # Server metadata
-    design.section_title("📊 Environment Overview")
+    hud_console.section_title("📊 Environment Overview")
     meta_table = Table(show_header=False, box=None)
-    meta_table.add_column("Property", style="dim")
+    meta_table.add_column("Property", style="bright_black")
     meta_table.add_column("Value")
 
     # Check if this is a live analysis (has metadata) or metadata-only analysis
@@ -126,19 +126,19 @@ def display_interactive(analysis: dict) -> None:
     console.print(meta_table)
 
     # Tools
-    design.section_title("🔧 Available Tools")
-    tools_tree = Tree("Tools")
+    hud_console.section_title("🔧 Available Tools")
+    tools_tree = Tree("[bold bright_white]Tools[/bold bright_white]")
 
     # Check if we have hub_tools info (live analysis) or not (metadata-only)
     if "hub_tools" in analysis:
         # Live analysis format - separate regular and hub tools
         # Regular tools
-        regular_tools = tools_tree.add("Regular Tools")
+        regular_tools = tools_tree.add("[bright_white]Regular Tools[/bright_white]")
         for tool in analysis["tools"]:
             if tool["name"] not in analysis["hub_tools"]:
-                tool_node = regular_tools.add(f"[default]{tool['name']}[/default]")
+                tool_node = regular_tools.add(f"[bright_white]{tool['name']}[/bright_white]")
                 if tool["description"]:
-                    tool_node.add(f"[dim]{tool['description']}[/dim]")
+                    tool_node.add(f"[bright_black]{tool['description']}[/bright_black]")
 
                 # Show input schema if verbose
                 if analysis.get("verbose") and tool.get("input_schema"):
@@ -148,17 +148,17 @@ def display_interactive(analysis: dict) -> None:
 
         # Hub tools
         if analysis["hub_tools"]:
-            hub_tools = tools_tree.add("Hub Tools")
+            hub_tools = tools_tree.add("[bright_white]Hub Tools[/bright_white]")
             for hub_name, functions in analysis["hub_tools"].items():
-                hub_node = hub_tools.add(f"[yellow]{hub_name}[/yellow]")
+                hub_node = hub_tools.add(f"[rgb(181,137,0)]{hub_name}[/rgb(181,137,0)]")
                 for func in functions:
-                    hub_node.add(f"[default]{func}[/default]")
+                    hub_node.add(f"[bright_white]{func}[/bright_white]")
     else:
         # Metadata-only format - just list all tools
         for tool in analysis["tools"]:
-            tool_node = tools_tree.add(f"[default]{tool['name']}[/default]")
+            tool_node = tools_tree.add(f"[bright_white]{tool['name']}[/bright_white]")
             if tool.get("description"):
-                tool_node.add(f"[dim]{tool['description']}[/dim]")
+                tool_node.add(f"[bright_black]{tool['description']}[/bright_black]")
 
             # Show input schema if verbose
             if tool.get("inputSchema"):
@@ -170,11 +170,11 @@ def display_interactive(analysis: dict) -> None:
 
     # Resources
     if analysis["resources"]:
-        design.section_title("📚 Available Resources")
+        hud_console.section_title("📚 Available Resources")
         resources_table = Table()
-        resources_table.add_column("URI", style="default")
-        resources_table.add_column("Name", style="white")
-        resources_table.add_column("Type", style="dim")
+        resources_table.add_column("URI", style="bright_white")
+        resources_table.add_column("Name", style="bright_white")
+        resources_table.add_column("Type", style="bright_black")
 
         for resource in analysis["resources"][:10]:
             resources_table.add_row(
@@ -184,11 +184,12 @@ def display_interactive(analysis: dict) -> None:
         console.print(resources_table)
 
         if len(analysis["resources"]) > 10:
-            console.print(f"[dim]... and {len(analysis['resources']) - 10} more resources[/dim]")
+            remaining = len(analysis["resources"]) - 10
+            console.print(f"[bright_black]... and {remaining} more resources[/bright_black]")
 
     # Telemetry (only for live analysis)
     if analysis.get("telemetry"):
-        design.section_title("📡 Telemetry Data")
+        hud_console.section_title("📡 Telemetry Data")
         telemetry_table = Table(show_header=False, box=None)
         telemetry_table.add_column("Key", style="dim")
         telemetry_table.add_column("Value")
@@ -206,7 +207,7 @@ def display_interactive(analysis: dict) -> None:
 
     # Environment variables (for metadata-only analysis)
     if analysis.get("env_vars"):
-        design.section_title("🔑 Environment Variables")
+        hud_console.section_title("🔑 Environment Variables")
         env_table = Table(show_header=False, box=None)
         env_table.add_column("Type", style="dim")
         env_table.add_column("Variables")
@@ -309,7 +310,7 @@ async def analyze_environment_from_config(
     config_path: Path, output_format: str, verbose: bool
 ) -> None:
     """Analyze MCP environment from a JSON config file."""
-    design.header("MCP Environment Analysis", icon="🔍")
+    hud_console.header("MCP Environment Analysis", icon="🔍")
 
     # Load config from file
     try:
@@ -327,7 +328,7 @@ async def analyze_environment_from_mcp_config(
     mcp_config: dict[str, Any], output_format: str, verbose: bool
 ) -> None:
     """Analyze MCP environment from MCP config dict."""
-    design.header("MCP Environment Analysis", icon="🔍")
+    hud_console.header("MCP Environment Analysis", icon="🔍")
     await _analyze_with_config(mcp_config, output_format, verbose)