hud-python 0.4.22__py3-none-any.whl → 0.4.24__py3-none-any.whl

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)
 
 

hud/cli/build.py

@@ -14,7 +14,7 @@ import typer
 import yaml
 
 from hud.clients import MCPClient
-from hud.utils.design import HUDDesign
+from hud.utils.hud_console import HUDConsole
 from hud.version import __version__ as hud_version
 
 from .utils.registry import save_to_registry
@@ -156,7 +156,7 @@ async def analyze_mcp_environment(
     image: str, verbose: bool = False, env_vars: dict[str, str] | None = None
 ) -> dict[str, Any]:
     """Analyze an MCP environment to extract metadata."""
-    design = HUDDesign()
+    hud_console = HUDConsole()
     env_vars = env_vars or {}
 
     # Build Docker command to run the image
@@ -180,7 +180,7 @@ async def analyze_mcp_environment(
 
     try:
         if verbose:
-            design.info(f"Initializing MCP client with command: {' '.join(docker_cmd)}")
+            hud_console.info(f"Initializing MCP client with command: {' '.join(docker_cmd)}")
 
         await client.initialize()
         initialized = True
@@ -215,7 +215,7 @@ async def analyze_mcp_environment(
                 await client.shutdown()
             except Exception:
                 # Ignore shutdown errors
-                design.warning("Failed to shutdown MCP client")
+                hud_console.warning("Failed to shutdown MCP client")
 
 
 def build_docker_image(
@@ -226,13 +226,13 @@ def build_docker_image(
     build_args: dict[str, str] | None = None,
 ) -> bool:
     """Build a Docker image from a directory."""
-    design = HUDDesign()
+    hud_console = HUDConsole()
     build_args = build_args or {}
 
     # Check if Dockerfile exists
     dockerfile = directory / "Dockerfile"
     if not dockerfile.exists():
-        design.error(f"No Dockerfile found in {directory}")
+        hud_console.error(f"No Dockerfile found in {directory}")
         return False
 
     # Build command
@@ -247,14 +247,14 @@ def build_docker_image(
     cmd.append(str(directory))
 
     # Always show build output
-    design.info(f"Running: {' '.join(cmd)}")
+    hud_console.info(f"Running: {' '.join(cmd)}")
 
     try:
         # Use Docker's native output formatting - no capture, let Docker handle display
         result = subprocess.run(cmd, check=False)  # noqa: S603
         return result.returncode == 0
     except Exception as e:
-        design.error(f"Build error: {e}")
+        hud_console.error(f"Build error: {e}")
         return False
 
 
@@ -266,20 +266,20 @@ def build_environment(
     env_vars: dict[str, str] | None = None,
 ) -> None:
     """Build a HUD environment and generate lock file."""
-    design = HUDDesign()
+    hud_console = HUDConsole()
     env_vars = env_vars or {}
-    design.header("HUD Environment Build")
+    hud_console.header("HUD Environment Build")
 
     # Resolve directory
     env_dir = Path(directory).resolve()
     if not env_dir.exists():
-        design.error(f"Directory not found: {directory}")
+        hud_console.error(f"Directory not found: {directory}")
         raise typer.Exit(1)
 
     # Check for pyproject.toml
     pyproject_path = env_dir / "pyproject.toml"
     if not pyproject_path.exists():
-        design.error(f"No pyproject.toml found in {directory}")
+        hud_console.error(f"No pyproject.toml found in {directory}")
         raise typer.Exit(1)
 
     # Read pyproject.toml to get image name
@@ -301,17 +301,17 @@ def build_environment(
     # Build temporary image first
     temp_tag = f"hud-build-temp:{int(time.time())}"
 
-    design.progress_message(f"Building Docker image: {temp_tag}")
+    hud_console.progress_message(f"Building Docker image: {temp_tag}")
 
     # Build the image (env vars are for runtime, not build time)
     if not build_docker_image(env_dir, temp_tag, no_cache, verbose):
-        design.error("Docker build failed")
+        hud_console.error("Docker build failed")
         raise typer.Exit(1)
 
-    design.success(f"Built temporary image: {temp_tag}")
+    hud_console.success(f"Built temporary image: {temp_tag}")
 
     # Analyze the environment
-    design.progress_message("Analyzing MCP environment...")
+    hud_console.progress_message("Analyzing MCP environment...")
 
     loop = asyncio.new_event_loop()
     asyncio.set_event_loop(loop)
@@ -320,7 +320,7 @@ def build_environment(
     finally:
         loop.close()
 
-    design.success(f"Analyzed environment: {analysis['toolCount']} tools found")
+    hud_console.success(f"Analyzed environment: {analysis['toolCount']} tools found")
 
     # Extract environment variables from Dockerfile
     dockerfile_path = env_dir / "Dockerfile"
@@ -335,14 +335,18 @@ def build_environment(
         missing_required = [e for e in required_env if e not in env_vars]
 
         # Show what env vars were provided
-        design.success(f"Using provided environment variables: {', '.join(env_vars.keys())}")
+        hud_console.success(f"Using provided environment variables: {', '.join(env_vars.keys())}")
     else:
         missing_required = required_env[:]
 
     # Warn about missing required variables
     if missing_required:
-        design.warning(f"Missing required environment variables: {', '.join(missing_required)}")
-        design.info("These can be added to the lock file after build or provided with -e flags")
+        hud_console.warning(
+            f"Missing required environment variables: {', '.join(missing_required)}"
+        )
+        hud_console.info(
+            "These can be added to the lock file after build or provided with -e flags"
+        )
 
     # Check for existing version and increment
     lock_path = env_dir / "hud.lock.yaml"
@@ -351,11 +355,11 @@ def build_environment(
     if existing_version:
         # Increment existing version
         new_version = increment_version(existing_version)
-        design.info(f"Incrementing version: {existing_version} → {new_version}")
+        hud_console.info(f"Incrementing version: {existing_version} → {new_version}")
     else:
         # Start with 0.1.0 for new environments
         new_version = "0.1.0"
-        design.info(f"Setting initial version: {new_version}")
+        hud_console.info(f"Setting initial version: {new_version}")
 
     # Create lock file content - minimal and useful
     lock_content = {
@@ -406,7 +410,7 @@ def build_environment(
     with open(lock_path, "w") as f:
         yaml.dump(lock_content, f, default_flow_style=False, sort_keys=False)
 
-    design.success("Created lock file: hud.lock.yaml")
+    hud_console.success("Created lock file: hud.lock.yaml")
 
     # Calculate lock file hash
     lock_content_str = yaml.dump(lock_content, default_flow_style=False, sort_keys=True)
@@ -414,7 +418,7 @@ def build_environment(
     lock_size = len(lock_content_str)
 
     # Rebuild with label containing lock file hash
-    design.progress_message("Rebuilding with lock file metadata...")
+    hud_console.progress_message("Rebuilding with lock file metadata...")
 
     # Build final image with label (uses cache from first build)
     # Also tag with version
@@ -447,10 +451,10 @@ def build_environment(
         )
 
     if result.returncode != 0:
-        design.error("Failed to rebuild with label")
+        hud_console.error("Failed to rebuild with label")
         raise typer.Exit(1)
 
-    design.success("Built final image with lock file metadata")
+    hud_console.success("Built final image with lock file metadata")
 
     # NOW get the image ID after the final build
     image_id = get_docker_image_id(tag)  # type: ignore
@@ -466,9 +470,9 @@ def build_environment(
         with open(lock_path, "w") as f:
             yaml.dump(lock_content, f, default_flow_style=False, sort_keys=False)
 
-        design.success("Updated lock file with image ID")
+        hud_console.success("Updated lock file with image ID")
     else:
-        design.warning("Could not retrieve image ID for lock file")
+        hud_console.warning("Could not retrieve image ID for lock file")
 
     # Remove temp image after we're done
     subprocess.run(["docker", "rmi", temp_tag], capture_output=True)  # noqa: S603, S607
@@ -479,30 +483,30 @@ def build_environment(
         save_to_registry(lock_content, lock_content.get("image", tag), verbose)
 
     # Print summary
-    design.section_title("Build Complete")
+    hud_console.section_title("Build Complete")
 
     # Show the version tag as primary since that's what will be pushed
-    design.status_item("Built image", version_tag, primary=True)
+    hud_console.status_item("Built image", version_tag, primary=True)
     if tag:
-        design.status_item("Also tagged", tag)
-    design.status_item("Version", new_version)
-    design.status_item("Lock file", "hud.lock.yaml")
-    design.status_item("Tools found", str(analysis["toolCount"]))
+        hud_console.status_item("Also tagged", tag)
+    hud_console.status_item("Version", new_version)
+    hud_console.status_item("Lock file", "hud.lock.yaml")
+    hud_console.status_item("Tools found", str(analysis["toolCount"]))
 
     # Show the digest info separately if we have it
     if image_id:
-        design.dim_info("\nImage digest", image_id)
-
-    design.section_title("Next Steps")
-    design.info("Test locally:")
-    design.command_example("hud dev", "Hot-reload development")
-    design.command_example(f"hud run {tag}", "Run the built image")
-    design.info("")
-    design.info("Publish to registry:")
-    design.command_example("hud push", f"Push as {version_tag}")
-    design.command_example("hud push --tag latest", "Push with custom tag")
-    design.info("")
-    design.info("The lock file can be used to reproduce this exact environment.")
+        hud_console.dim_info("\nImage digest", image_id)
+
+    hud_console.section_title("Next Steps")
+    hud_console.info("Test locally:")
+    hud_console.command_example("hud dev", "Hot-reload development")
+    hud_console.command_example(f"hud run {tag}", "Run the built image")
+    hud_console.info("")
+    hud_console.info("Publish to registry:")
+    hud_console.command_example("hud push", f"Push as {version_tag}")
+    hud_console.command_example("hud push --tag latest", "Push with custom tag")
+    hud_console.info("")
+    hud_console.info("The lock file can be used to reproduce this exact environment.")
 
 
 def build_command(

hud/cli/debug.py

@@ -12,7 +12,7 @@ import time
 from rich.console import Console
 
 from hud.clients import MCPClient
-from hud.utils.design import HUDDesign
+from hud.utils.hud_console import HUDConsole
 
 from .utils.logging import CaptureLogger, Colors, analyze_error_for_hints
 
@@ -31,15 +31,15 @@ async def debug_mcp_stdio(command: list[str], logger: CaptureLogger, max_phase:
     Returns:
         Number of phases completed (0-5)
     """
-    # Create design instance for initial output (before logger takes over)
+    # Create hud_console instance for initial output (before logger takes over)
     if logger.print_output:
-        design = HUDDesign()
-        design.header("MCP Server Debugger", icon="🔍")
-        design.dim_info("Command:", " ".join(command))
-        design.dim_info("Time:", time.strftime("%Y-%m-%d %H:%M:%S"))
+        hud_console = HUDConsole()
+        hud_console.header("MCP Server Debugger", icon="🔍")
+        hud_console.dim_info("Command:", " ".join(command))
+        hud_console.dim_info("Time:", time.strftime("%Y-%m-%d %H:%M:%S"))
 
         # Explain color coding using Rich formatting
-        design.info("\nColor Key:")
+        hud_console.info("\nColor Key:")
         console.print("  [bold]■[/bold] Commands (bold)")
         console.print("  [rgb(192,150,12)]■[/rgb(192,150,12)] STDIO (MCP protocol)")
         console.print("  [dim]■[/dim] STDERR (server logs)")