ha-mcp-dev 7.2.0.dev330__py3-none-any.whl → 7.2.0.dev332__py3-none-any.whl

ha_mcp/tools/backup.py

@@ -51,7 +51,7 @@ def _get_backup_hint_text() -> str:
 
 async def _get_backup_password(
     ws_client: HomeAssistantWebSocketClient,
-) -> tuple[str | None, dict[str, Any] | None]:
+) -> str:
     """
     Retrieve default backup password from Home Assistant configuration.
 
@@ -59,27 +59,30 @@ async def _get_backup_password(
         ws_client: Connected WebSocket client
 
     Returns:
-        Tuple of (password, error_dict). If retrieval fails, password is None.
+        The backup password string.
+
+    Raises:
+        ToolError: If backup config cannot be retrieved or no password is configured.
     """
     backup_config = await ws_client.send_command("backup/config/info")
     if not backup_config.get("success"):
-        return None, {
-            "success": False,
-            "error": "Failed to retrieve backup configuration",
-            "details": backup_config,
-        }
+        raise_tool_error(create_error_response(
+            ErrorCode.SERVICE_CALL_FAILED,
+            "Failed to retrieve backup configuration",
+            context={"details": backup_config},
+        ))
 
     config_data = backup_config.get("result", {}).get("config", {})
     default_password = config_data.get("create_backup", {}).get("password")
 
     if not default_password:
-        return None, {
-            "success": False,
-            "error": "No default backup password configured in Home Assistant",
-            "suggestion": "Configure automatic backups in Home Assistant settings to set a default password",
-        }
+        raise_tool_error(create_error_response(
+            ErrorCode.SERVICE_CALL_FAILED,
+            "No default backup password configured in Home Assistant",
+            suggestions=["Configure automatic backups in Home Assistant settings to set a default password"],
+        ))
 
-    return default_password, None
+    return cast(str, default_password)
 
 
 async def create_backup(
@@ -107,13 +110,8 @@ async def create_backup(
             ))
         ws_client = cast(HomeAssistantWebSocketClient, ws_client)
 
-        # Get backup password
-        password, error = await _get_backup_password(ws_client)
-        if error:
-            raise_tool_error(create_error_response(
-                ErrorCode.SERVICE_CALL_FAILED,
-                error.get("error", "Failed to retrieve backup password"),
-            ))
+        # Get backup password (raises ToolError on failure)
+        password = await _get_backup_password(ws_client)
 
         # Generate backup name if not provided
         if not name:
@@ -283,12 +281,15 @@ async def restore_backup(
         safety_backup_name = f"PreRestore_Safety_{now.strftime('%Y-%m-%d_%H:%M:%S')}"
 
         # Get backup password
-        password, error = await _get_backup_password(ws_client)
-        if error:
+        try:
+            password = await _get_backup_password(ws_client)
+        except ToolError:
             # Password error - log warning but continue (restore might still work)
             logger.warning("No default password - proceeding without safety backup")
+            password = None
             safety_backup_id = None
-        else:
+
+        if password is not None:
             safety_backup = await ws_client.send_command(
                 "backup/generate",
                 name=safety_backup_name,

ha_mcp/tools/device_control.py

@@ -421,38 +421,40 @@ class DeviceControlTools:
             }
 
         elif operation.status.value == "failed":
-            return {
-                "operation_id": operation_id,
-                "status": "failed",
-                "success": False,
-                "entity_id": operation.entity_id,
-                "action": operation.action,
-                "error": operation.error_message,
-                "duration_ms": operation.duration_ms,
-                "suggestions": [
+            raise_tool_error(create_error_response(
+                ErrorCode.SERVICE_CALL_FAILED,
+                operation.error_message or "Device operation failed",
+                context={
+                    "operation_id": operation_id,
+                    "entity_id": operation.entity_id,
+                    "action": operation.action,
+                    "duration_ms": operation.duration_ms,
+                },
+                suggestions=[
                     "Check if device is available and responding",
                     "Verify device supports the requested action",
                     "Check Home Assistant logs for error details",
                     "Try a simpler action like toggle",
                 ],
-            }
+            ))
 
         elif operation.status.value == "timeout":
-            return {
-                "operation_id": operation_id,
-                "status": "timeout",
-                "success": False,
-                "entity_id": operation.entity_id,
-                "action": operation.action,
-                "error": f"Operation timed out after {operation.timeout_ms}ms",
-                "elapsed_ms": operation.elapsed_ms,
-                "suggestions": [
+            raise_tool_error(create_error_response(
+                ErrorCode.TIMEOUT_OPERATION,
+                f"Operation timed out after {operation.timeout_ms}ms",
+                context={
+                    "operation_id": operation_id,
+                    "entity_id": operation.entity_id,
+                    "action": operation.action,
+                    "elapsed_ms": operation.elapsed_ms,
+                },
+                suggestions=[
                     "Device may be slow to respond or offline",
                     "Check device connectivity",
                     "Try increasing timeout for slow devices",
                     "Verify device is powered on",
                 ],
-            }
+            ))
 
         else:  # pending
             return {

ha_mcp/tools/tools_entities.py

@@ -240,21 +240,20 @@ def register_entity_tools(mcp: Any, client: Any, **kwargs: Any) -> None:
                         else str(error)
                     )
                     failed = dict.fromkeys(assistants, should_expose)
-                    response: dict[str, Any] = {
-                        "success": False,
-                        "error": {
-                            "code": ErrorCode.SERVICE_CALL_FAILED.value,
-                            "message": f"Exposure failed: {error_msg}",
-                            "suggestion": "Check Home Assistant connection and entity availability",
-                        },
+                    context: dict[str, Any] = {
                         "entity_id": entity_id,
                         "exposure_succeeded": succeeded,
                         "exposure_failed": failed,
                     }
                     if has_registry_updates:
-                        response["partial"] = True
-                        response["entity_entry"] = _format_entity_entry(entity_entry)
-                    return response
+                        context["partial"] = True
+                        context["entity_entry"] = _format_entity_entry(entity_entry)
+                    raise_tool_error(create_error_response(
+                        ErrorCode.SERVICE_CALL_FAILED,
+                        f"Exposure failed: {error_msg}",
+                        context=context,
+                        suggestions=["Check Home Assistant connection and entity availability"],
+                    ))
 
                 # Track successful exposures
                 for a in assistants:
@@ -272,21 +271,15 @@ def register_entity_tools(mcp: Any, client: Any, **kwargs: Any) -> None:
             if get_result.get("success"):
                 entity_entry = get_result.get("result", {})
             else:
-                # Return plain dict so caller can inspect exposure_succeeded
-                return {
-                    "success": False,
-                    "error": {
-                        "code": ErrorCode.ENTITY_NOT_FOUND.value,
-                        "message": f"Entity '{entity_id}' not found in registry after applying exposure changes",
-                        "suggestion": "Use ha_search_entities() to verify the entity exists",
-                    },
-                    "entity_id": entity_id,
-                    "suggestions": [
+                raise_tool_error(create_error_response(
+                    ErrorCode.ENTITY_NOT_FOUND,
+                    f"Entity '{entity_id}' not found in registry after applying exposure changes",
+                    context={"entity_id": entity_id, "exposure_succeeded": exposure_result},
+                    suggestions=[
                         "Verify the entity_id exists using ha_search_entities()",
                         "The entity's exposure settings were likely changed, but its current state could not be confirmed.",
                     ],
-                    "exposure_succeeded": exposure_result,
-                }
+                ))
 
         response_data: dict[str, Any] = {
             "success": True,
@@ -831,15 +824,10 @@ def register_entity_tools(mcp: Any, client: Any, **kwargs: Any) -> None:
                         if isinstance(error, dict)
                         else str(error)
                     )
-                    return {
-                        "success": False,
-                        "entity_id": eid,
-                        "error": error_msg,
-                    }
+                    raise ValueError(error_msg)
 
                 entry = result.get("result", {})
                 return {
-                    "success": True,
                     "entity_id": entry.get("entity_id"),
                     "name": entry.get("name"),
                     "original_name": entry.get("original_name"),
@@ -861,21 +849,13 @@ def register_entity_tools(mcp: Any, client: Any, **kwargs: Any) -> None:
             if not is_bulk:
                 eid = entity_ids[0]
                 logger.info(f"Getting entity registry entry for {eid}")
-                result = await _fetch_entity(eid)
-
-                if result.get("success"):
-                    return {
-                        "success": True,
-                        "entity_id": eid,
-                        "entity_entry": {
-                            k: v for k, v in result.items() if k not in ("success",)
-                        },
-                    }
-                else:
+                try:
+                    result = await _fetch_entity(eid)
+                except ValueError as e:
                     raise_tool_error(
                         create_error_response(
                             ErrorCode.SERVICE_CALL_FAILED,
-                            f"Entity not found: {result.get('error', 'Unknown error')}",
+                            f"Entity not found: {e}",
                             context={"entity_id": eid},
                             suggestions=[
                                 "Use ha_search_entities() to find valid entity IDs",
@@ -883,6 +863,11 @@ def register_entity_tools(mcp: Any, client: Any, **kwargs: Any) -> None:
                             ],
                         )
                     )
+                return {
+                    "success": True,
+                    "entity_id": eid,
+                    "entity_entry": result,
+                }
 
             # Bulk case - fetch all entities
             logger.info(
@@ -904,18 +889,8 @@ def register_entity_tools(mcp: Any, client: Any, **kwargs: Any) -> None:
                             "error": str(fetch_result),
                         }
                     )
-                    continue
-                if fetch_result.get("success"):
-                    entity_entries.append(
-                        {k: v for k, v in fetch_result.items() if k not in ("success",)}
-                    )
                 else:
-                    errors.append(
-                        {
-                            "entity_id": eid,
-                            "error": fetch_result.get("error", "Unknown error"),
-                        }
-                    )
+                    entity_entries.append(fetch_result)
 
             response: dict[str, Any] = {
                 "success": True,

ha_mcp/tools/tools_hacs.py

@@ -13,7 +13,7 @@ from pydantic import Field
 
 from ..errors import ErrorCode, create_error_response
 from .helpers import exception_to_structured_error, log_tool_usage, raise_tool_error
-from .util_helpers import add_timezone_metadata, coerce_int_param
+from .util_helpers import add_timezone_metadata, coerce_bool_param, coerce_int_param
 
 logger = logging.getLogger(__name__)
 
@@ -33,220 +33,85 @@ CATEGORY_DISPLAY = {v: k for k, v in CATEGORY_MAP.items()}
 CATEGORY_DISPLAY["plugin"] = "lovelace"  # Display as lovelace for users
 
 
-async def _is_hacs_available() -> bool:
-    """Return True if HACS is installed and responding via WebSocket.
-
-    Raises if the WebSocket connection fails — callers handle API errors via
-    their own exception_to_structured_error blocks.
-    """
-    from ..client.websocket_client import get_websocket_client
-    ws_client = await get_websocket_client()
-    response = await ws_client.send_command("hacs/info")
-    return bool(response.get("success"))
-
-
 async def _assert_hacs_available() -> None:
-    """Raise ToolError if HACS is not available.
+    """Raise ToolError if HACS is not installed or not responding.
+
+    Distinguishes "unknown command" (HACS not installed) from other failures
+    (HACS installed but broken) so the error message is accurate.
 
     Must be called within a try block that handles API errors via
     exception_to_structured_error, so connection failures are classified
     correctly rather than masked as COMPONENT_NOT_INSTALLED.
     """
-    if not await _is_hacs_available():
-        raise_tool_error(create_error_response(
+    from ..client.websocket_client import get_websocket_client
+
+    ws_client = await get_websocket_client()
+    response = await ws_client.send_command("hacs/info")
+    if response.get("success"):
+        return
+
+    error = response.get("error", {})
+    error_code = error.get("code") if isinstance(error, dict) else None
+    error_message = (
+        error.get("message", "") if isinstance(error, dict) else str(error)
+    )
+
+    # "unknown_command" means HACS is not installed at all
+    if error_code == "unknown_command" or "unknown command" in error_message.lower():
+        raise_tool_error(
+            create_error_response(
+                ErrorCode.COMPONENT_NOT_INSTALLED,
+                "HACS is not installed.",
+                suggestions=[
+                    "Install HACS from https://hacs.xyz/",
+                    "Restart Home Assistant after HACS installation",
+                ],
+            )
+        )
+
+    # HACS is installed but not responding correctly
+    raise_tool_error(
+        create_error_response(
             ErrorCode.COMPONENT_NOT_INSTALLED,
-            "HACS is not installed or not loaded.",
+            f"HACS is installed but not responding: {error_message or 'unknown error'}",
             suggestions=[
-                "Install HACS from https://hacs.xyz/",
-                "Restart Home Assistant after HACS installation",
+                "Restart Home Assistant",
                 "Check Home Assistant logs for HACS errors",
+                "Verify HACS is up to date",
             ],
-        ))
+        )
+    )
 
 
 def register_hacs_tools(mcp: Any, client: Any, **kwargs: Any) -> None:
     """Register HACS integration tools with the MCP server."""
 
-    @mcp.tool(tags={"HACS"}, annotations={"idempotentHint": True, "readOnlyHint": True, "title": "Get HACS Info"})
-    @log_tool_usage
-    async def ha_hacs_info() -> dict[str, Any]:
-        """Get HACS status, version, and enabled categories.
-
-        Returns information about the HACS installation including:
-        - Version number
-        - Enabled categories (integration, lovelace, theme, etc.)
-        - Stage (running, startup, etc.)
-        - Lovelace mode
-        - Disabled reason (if any)
-
-        This is useful for validating that HACS is installed and operational
-        before using other HACS tools.
-
-        **HACS Installation:**
-        If HACS is not installed, visit https://hacs.xyz/ for installation instructions.
-
-        Returns:
-            Dictionary with HACS status information or error if HACS is not available.
-        """
-        try:
-            # Check if HACS is available
-            await _assert_hacs_available()
-
-            # Get HACS info via WebSocket
-            from ..client.websocket_client import get_websocket_client
-            ws_client = await get_websocket_client()
-            response = await ws_client.send_command("hacs/info")
-
-            if not response.get("success"):
-                exception_to_structured_error(
-                    Exception(f"HACS info request failed: {response}"),
-                    context={"command": "hacs/info"},
-                    raise_error=True,
-                )
-
-            result = response.get("result", {})
-
-            return await add_timezone_metadata(client, {
-                "success": True,
-                "version": result.get("version"),
-                "categories": result.get("categories", []),
-                "stage": result.get("stage"),
-                "lovelace_mode": result.get("lovelace_mode"),
-                "disabled_reason": result.get("disabled_reason"),
-                "data": result,
-            })
-
-        except ToolError:
-            raise
-        except Exception as e:
-            exception_to_structured_error(
-                e,
-                context={"tool": "ha_hacs_info"},
-                suggestions=[
-                    "Verify HACS is installed: https://hacs.xyz/",
-                    "Check Home Assistant connection",
-                    "Restart Home Assistant if HACS was recently installed",
-                ],
-            )
-
-    @mcp.tool(tags={"HACS"}, annotations={"idempotentHint": True, "readOnlyHint": True, "title": "List HACS Installed"})
-    @log_tool_usage
-    async def ha_hacs_list_installed(
-        category: Annotated[
-            Literal["integration", "lovelace", "theme", "appdaemon", "python_script"] | None,
-            Field(
-                default=None,
-                description=(
-                    "Filter by category: 'integration', 'lovelace', 'theme', "
-                    "'appdaemon', or 'python_script'. Use None for all categories."
-                ),
-            ),
-        ] = None,
-    ) -> dict[str, Any]:
-        """List installed HACS repositories with focused, small response.
-
-        **DASHBOARD TIP:** Use `category="lovelace"` to discover installed custom cards
-        for use with `ha_config_set_dashboard()`.
-
-        Returns a list of installed repositories with key information:
-        - name: Repository name
-        - full_name: Full GitHub repository name (owner/repo)
-        - category: Type of repository (integration, lovelace, theme, etc.)
-        - installed_version: Currently installed version
-        - available_version: Latest available version
-        - pending_update: Whether an update is available
-        - description: Repository description
-
-        **Categories:**
-        - `integration`: Custom integrations and components
-        - `lovelace`: Custom dashboard cards and panels
-        - `theme`: Custom themes for the UI
-        - `appdaemon`: AppDaemon apps
-        - `python_script`: Python scripts
-
-        Args:
-            category: Filter results by category (default: all categories)
-
-        Returns:
-            List of installed HACS repositories or error if HACS is not available.
-        """
-        try:
-            # Check if HACS is available
-            await _assert_hacs_available()
-
-            # Get installed repositories via WebSocket
-            from ..client.websocket_client import get_websocket_client
-            ws_client = await get_websocket_client()
-
-            # Build command parameters - map user-friendly category to HACS internal name
-            kwargs_cmd: dict[str, Any] = {}
-            if category:
-                hacs_category = CATEGORY_MAP.get(category, category)
-                kwargs_cmd["categories"] = [hacs_category]
-
-            response = await ws_client.send_command("hacs/repositories/list", **kwargs_cmd)
-
-            if not response.get("success"):
-                exception_to_structured_error(
-                    Exception(f"HACS repositories list request failed: {response}"),
-                    context={"command": "hacs/repositories/list", "category": category},
-                    raise_error=True,
-                )
-
-            repositories = response.get("result", [])
-
-            # Filter to only installed repositories and extract key info
-            installed = []
-            for repo in repositories:
-                if repo.get("installed", False):
-                    # Map HACS internal category back to user-friendly name
-                    repo_category = repo.get("category", "")
-                    display_category = CATEGORY_DISPLAY.get(repo_category, repo_category)
-                    installed.append({
-                        "name": repo.get("name"),
-                        "full_name": repo.get("full_name"),
-                        "category": display_category,
-                        "id": repo.get("id"),  # Include numeric ID for repository_info
-                        "installed_version": repo.get("installed_version"),
-                        "available_version": repo.get("available_version"),
-                        "pending_update": repo.get("pending_upgrade", False),
-                        "description": repo.get("description"),
-                        "authors": repo.get("authors", []),
-                        "domain": repo.get("domain"),  # For integrations
-                        "stars": repo.get("stars", 0),
-                    })
-
-            return await add_timezone_metadata(client, {
-                "success": True,
-                "category_filter": category,
-                "total_installed": len(installed),
-                "repositories": installed,
-            })
-
-        except ToolError:
-            raise
-        except Exception as e:
-            exception_to_structured_error(
-                e,
-                context={"tool": "ha_hacs_list_installed", "category": category},
-                suggestions=[
-                    "Verify HACS is installed: https://hacs.xyz/",
-                    "Check category name is valid: integration, lovelace, theme, appdaemon, python_script",
-                    "Check Home Assistant connection",
-                ],
-            )
-
-    @mcp.tool(tags={"HACS"}, annotations={"idempotentHint": True, "readOnlyHint": True, "title": "Search HACS Store"})
+    @mcp.tool(
+        tags={"HACS"},
+        annotations={
+            "idempotentHint": True,
+            "readOnlyHint": True,
+            "title": "Search HACS Store",
+        },
+    )
     @log_tool_usage
     async def ha_hacs_search(
-        query: str,
+        query: str = "",
         category: Annotated[
-            Literal["integration", "lovelace", "theme", "appdaemon", "python_script"] | None,
+            Literal["integration", "lovelace", "theme", "appdaemon", "python_script"]
+            | None,
             Field(
                 default=None,
                 description="Filter by category (optional)",
             ),
         ] = None,
+        installed_only: Annotated[
+            bool | str,
+            Field(
+                default=False,
+                description="Only return installed repositories (default: False)",
+            ),
+        ] = False,
         max_results: Annotated[
             int | str,
             Field(
@@ -262,56 +127,55 @@ def register_hacs_tools(mcp: Any, client: Any, **kwargs: Any) -> None:
             ),
         ] = 0,
     ) -> dict[str, Any]:
-        """Search HACS store for repositories by keyword with pagination.
+        """Search HACS store for repositories, or list installed repositories.
 
-        Searches the HACS store for repositories matching the query string.
-        Returns repository information including stars, downloads, and descriptions.
+        **Search mode** (default): Searches by keyword across name, description, and authors.
+        **Browse mode** (no query, `installed_only=False`): Returns all HACS store repos
+        sorted alphabetically, paginated by `max_results` and `offset`.
+        **Installed mode** (`installed_only=True`): Lists installed repos (no query needed).
 
-        **Use Cases:**
+        **DASHBOARD TIP:** Use `installed_only=True, category="lovelace"` to discover
+        installed custom cards for use with `ha_config_set_dashboard()`.
+
+        **Examples:**
         - Find custom cards: `ha_hacs_search("mushroom", category="lovelace")`
         - Find integrations: `ha_hacs_search("nest", category="integration")`
-        - Browse themes: `ha_hacs_search("dark", category="theme")`
-
-        Results include:
-        - name: Repository name
-        - full_name: Full GitHub repository name
-        - description: Repository description
-        - category: Type of repository
-        - stars: GitHub stars count
-        - downloads: Number of HACS installations
-        - authors: Repository authors
-        - installed: Whether already installed
+        - List installed: `ha_hacs_search(installed_only=True)`
+        - Installed by category: `ha_hacs_search(installed_only=True, category="lovelace")`
 
         Args:
-            query: Search query (repository name, description, author)
+            query: Search query (repository name, description, author). Empty string with
+                  installed_only=True lists all installed repos.
             category: Filter by category (optional)
+            installed_only: Only return installed repositories (default: False)
             max_results: Maximum results to return (default: 10, max: 100)
             offset: Number of results to skip for pagination (default: 0)
-
-        Returns:
-            Search results from HACS store or error if HACS is not available.
         """
         try:
-            # Coerce max_results and offset to int
+            # Coerce parameters
+            installed_only_bool = coerce_bool_param(
+                installed_only, "installed_only", default=False
+            )
             max_results_int = coerce_int_param(
                 max_results,
                 "max_results",
                 default=10,
                 min_value=1,
                 max_value=100,
-            ) or 10
+            )
             offset_int = coerce_int_param(
                 offset,
                 "offset",
                 default=0,
                 min_value=0,
-            ) or 0
+            )
 
             # Check if HACS is available
             await _assert_hacs_available()
 
             # Get all repositories via WebSocket
             from ..client.websocket_client import get_websocket_client
+
             ws_client = await get_websocket_client()
 
             # Build command parameters - map user-friendly category to HACS internal name
@@ -320,22 +184,31 @@ def register_hacs_tools(mcp: Any, client: Any, **kwargs: Any) -> None:
                 hacs_category = CATEGORY_MAP.get(category, category)
                 kwargs_cmd["categories"] = [hacs_category]
 
-            response = await ws_client.send_command("hacs/repositories/list", **kwargs_cmd)
+            response = await ws_client.send_command(
+                "hacs/repositories/list", **kwargs_cmd
+            )
 
             if not response.get("success"):
                 exception_to_structured_error(
                     Exception(f"HACS search request failed: {response}"),
-                    context={"command": "hacs/repositories/list", "query": query, "category": category},
+                    context={
+                        "command": "hacs/repositories/list",
+                        "query": query,
+                        "category": category,
+                    },
                     raise_error=True,
                 )
 
             all_repositories = response.get("result", [])
 
-            # Simple search: filter by query string in name, description, or authors
             query_lower = query.lower().strip()
             matches = []
 
             for repo in all_repositories:
+                # Filter to installed only when requested
+                if installed_only_bool and not repo.get("installed", False):
+                    continue
+
                 # Handle None values safely
                 name = (repo.get("name") or "").lower()
                 description = (repo.get("description") or "").lower()
@@ -343,60 +216,83 @@ def register_hacs_tools(mcp: Any, client: Any, **kwargs: Any) -> None:
                 authors_list = repo.get("authors") or []
                 authors = " ".join(authors_list).lower()
 
-                # Calculate relevance score
-                score = 0
-                if query_lower in name:
-                    score += 100
-                if query_lower in full_name:
-                    score += 50
-                if query_lower in description:
-                    score += 30
-                if query_lower in authors:
-                    score += 20
-
-                if score > 0:
-                    # Map HACS internal category back to user-friendly name
-                    repo_category = repo.get("category", "")
-                    display_category = CATEGORY_DISPLAY.get(repo_category, repo_category)
-                    matches.append({
-                        "name": repo.get("name"),
-                        "full_name": repo.get("full_name"),
-                        "description": repo.get("description"),
-                        "category": display_category,
-                        "id": repo.get("id"),  # Include numeric ID for repository_info
-                        "stars": repo.get("stars", 0),
-                        "downloads": repo.get("downloads", 0),
-                        "authors": authors_list,
-                        "installed": repo.get("installed", False),
-                        "installed_version": repo.get("installed_version") if repo.get("installed") else None,
-                        "available_version": repo.get("available_version"),
-                        "score": score,
-                    })
-
-            # Sort by score (descending) and apply offset + limit
-            matches.sort(key=lambda x: x["score"], reverse=True)
-            limited_matches = matches[offset_int:offset_int + max_results_int]
+                # Calculate relevance score (all repos match when query is empty)
+                if query_lower:
+                    score = 0
+                    if query_lower in name:
+                        score += 100
+                    if query_lower in full_name:
+                        score += 50
+                    if query_lower in description:
+                        score += 30
+                    if query_lower in authors:
+                        score += 20
+                    if score == 0:
+                        continue
+                else:
+                    score = 0  # No scoring when listing all
+
+                # Map HACS internal category back to user-friendly name
+                repo_category = repo.get("category", "")
+                display_category = CATEGORY_DISPLAY.get(repo_category, repo_category)
+                entry: dict[str, Any] = {
+                    "name": repo.get("name"),
+                    "full_name": repo.get("full_name"),
+                    "description": repo.get("description"),
+                    "category": display_category,
+                    "id": repo.get("id"),
+                    "stars": repo.get("stars", 0),
+                    "downloads": repo.get("downloads", 0),
+                    "authors": authors_list,
+                    "installed": repo.get("installed", False),
+                    "installed_version": repo.get("installed_version")
+                    if repo.get("installed")
+                    else None,
+                    "available_version": repo.get("available_version"),
+                }
+                if query_lower:
+                    entry["score"] = score
+                if repo.get("installed"):
+                    entry["pending_update"] = repo.get("pending_upgrade", False)
+                    entry["domain"] = repo.get("domain")
+                matches.append(entry)
+
+            # Sort by score (descending) when searching, by name when listing
+            if query_lower:
+                matches.sort(key=lambda x: x.get("score", 0), reverse=True)
+            else:
+                matches.sort(key=lambda x: (x.get("name") or "").lower())
+
+            limited_matches = matches[offset_int : offset_int + max_results_int]
             has_more = (offset_int + len(limited_matches)) < len(matches)
 
-            return await add_timezone_metadata(client, {
-                "success": True,
-                "query": query,
-                "category_filter": category,
-                "total_matches": len(matches),
-                "offset": offset_int,
-                "limit": max_results_int,
-                "count": len(limited_matches),
-                "has_more": has_more,
-                "next_offset": offset_int + max_results_int if has_more else None,
-                "results": limited_matches,
-            })
+            return await add_timezone_metadata(
+                client,
+                {
+                    "success": True,
+                    "query": query if query_lower else None,
+                    "category_filter": category,
+                    "installed_only": installed_only_bool,
+                    "total_matches": len(matches),
+                    "offset": offset_int,
+                    "limit": max_results_int,
+                    "count": len(limited_matches),
+                    "has_more": has_more,
+                    "next_offset": offset_int + max_results_int if has_more else None,
+                    "results": limited_matches,
+                },
+            )
 
         except ToolError:
             raise
         except Exception as e:
             exception_to_structured_error(
                 e,
-                context={"tool": "ha_hacs_search", "query": query, "category": category},
+                context={
+                    "tool": "ha_hacs_search",
+                    "query": query,
+                    "category": category,
+                },
                 suggestions=[
                     "Verify HACS is installed: https://hacs.xyz/",
                     "Try a simpler search query",
@@ -404,7 +300,14 @@ def register_hacs_tools(mcp: Any, client: Any, **kwargs: Any) -> None:
                 ],
             )
 
-    @mcp.tool(tags={"HACS"}, annotations={"idempotentHint": True, "readOnlyHint": True, "title": "Get HACS Repository Info"})
+    @mcp.tool(
+        tags={"HACS"},
+        annotations={
+            "idempotentHint": True,
+            "readOnlyHint": True,
+            "title": "Get HACS Repository Info",
+        },
+    )
     @log_tool_usage
     async def ha_hacs_repository_info(repository_id: str) -> dict[str, Any]:
         """Get detailed repository information including README and documentation.
@@ -423,7 +326,7 @@ def register_hacs_tools(mcp: Any, client: Any, **kwargs: Any) -> None:
         - Find theme customization options
 
         **Note:** The repository_id is the numeric ID from HACS, not the GitHub path.
-        Use `ha_hacs_list_installed()` or `ha_hacs_search()` to find the numeric ID.
+        Use `ha_hacs_search()` to find the numeric ID.
 
         Args:
             repository_id: Repository numeric ID (e.g., "441028036") or GitHub path (e.g., "dvd-dev/hilo")
@@ -436,6 +339,7 @@ def register_hacs_tools(mcp: Any, client: Any, **kwargs: Any) -> None:
             await _assert_hacs_available()
 
             from ..client.websocket_client import get_websocket_client
+
             ws_client = await get_websocket_client()
 
             # If repository_id contains a slash, it's a GitHub path - need to look up numeric ID
@@ -450,58 +354,70 @@ def register_hacs_tools(mcp: Any, client: Any, **kwargs: Any) -> None:
                             actual_id = str(repo.get("id"))
                             break
                     else:
-                        return await add_timezone_metadata(client, {
-                            "success": False,
-                            "error": f"Repository '{repository_id}' not found in HACS",
-                            "error_code": "REPOSITORY_NOT_FOUND",
-                            "suggestions": [
-                                "Use ha_hacs_search() to find the repository",
-                                "Check the repository name is correct (case-insensitive)",
-                                "The repository may need to be added to HACS first",
-                            ],
-                        })
+                        raise_tool_error(
+                            create_error_response(
+                                ErrorCode.RESOURCE_NOT_FOUND,
+                                f"Repository '{repository_id}' not found in HACS",
+                                suggestions=[
+                                    "Use ha_hacs_search() to find the repository",
+                                    "Check the repository name is correct (case-insensitive)",
+                                    "The repository may need to be added to HACS first",
+                                ],
+                            )
+                        )
 
             # Get repository info via WebSocket using numeric ID
-            response = await ws_client.send_command("hacs/repository/info", repository_id=actual_id)
+            response = await ws_client.send_command(
+                "hacs/repository/info", repository_id=actual_id
+            )
 
             if not response.get("success"):
                 exception_to_structured_error(
                     Exception(f"HACS repository info request failed: {response}"),
-                    context={"command": "hacs/repository/info", "repository_id": repository_id},
+                    context={
+                        "command": "hacs/repository/info",
+                        "repository_id": repository_id,
+                    },
                     raise_error=True,
                 )
 
             result = response.get("result", {})
 
             # Extract and structure the most useful information
-            return await add_timezone_metadata(client, {
-                "success": True,
-                "repository_id": repository_id,
-                "name": result.get("name"),
-                "full_name": result.get("full_name"),
-                "description": result.get("description"),
-                "category": result.get("category"),
-                "authors": result.get("authors", []),
-                "domain": result.get("domain"),  # For integrations
-                "installed": result.get("installed", False),
-                "installed_version": result.get("installed_version"),
-                "available_version": result.get("available_version"),
-                "pending_update": result.get("pending_upgrade", False),
-                "stars": result.get("stars", 0),
-                "downloads": result.get("downloads", 0),
-                "topics": result.get("topics", []),
-                "releases": result.get("releases", []),
-                "default_branch": result.get("default_branch"),
-                "readme": result.get("readme"),  # Full README content
-                "data": result,  # Full response for advanced use
-            })
+            return await add_timezone_metadata(
+                client,
+                {
+                    "success": True,
+                    "repository_id": repository_id,
+                    "name": result.get("name"),
+                    "full_name": result.get("full_name"),
+                    "description": result.get("description"),
+                    "category": result.get("category"),
+                    "authors": result.get("authors", []),
+                    "domain": result.get("domain"),  # For integrations
+                    "installed": result.get("installed", False),
+                    "installed_version": result.get("installed_version"),
+                    "available_version": result.get("available_version"),
+                    "pending_update": result.get("pending_upgrade", False),
+                    "stars": result.get("stars", 0),
+                    "downloads": result.get("downloads", 0),
+                    "topics": result.get("topics", []),
+                    "releases": result.get("releases", []),
+                    "default_branch": result.get("default_branch"),
+                    "readme": result.get("readme"),  # Full README content
+                    "data": result,  # Full response for advanced use
+                },
+            )
 
         except ToolError:
             raise
         except Exception as e:
             exception_to_structured_error(
                 e,
-                context={"tool": "ha_hacs_repository_info", "repository_id": repository_id},
+                context={
+                    "tool": "ha_hacs_repository_info",
+                    "repository_id": repository_id,
+                },
                 suggestions=[
                     "Verify HACS is installed: https://hacs.xyz/",
                     "Check repository ID format (e.g., 'hacs/integration' or 'owner/repo')",
@@ -509,7 +425,10 @@ def register_hacs_tools(mcp: Any, client: Any, **kwargs: Any) -> None:
                 ],
             )
 
-    @mcp.tool(tags={"HACS"}, annotations={"destructiveHint": True, "title": "Add HACS Repository"})
+    @mcp.tool(
+        tags={"HACS"},
+        annotations={"destructiveHint": True, "title": "Add HACS Repository"},
+    )
     @log_tool_usage
     async def ha_hacs_add_repository(
         repository: str,
@@ -559,18 +478,20 @@ def register_hacs_tools(mcp: Any, client: Any, **kwargs: Any) -> None:
 
             # Validate repository format
             if "/" not in repository:
-                return await add_timezone_metadata(client, {
-                    "success": False,
-                    "error": "Invalid repository format. Must be 'owner/repo'",
-                    "error_code": "INVALID_REPOSITORY_FORMAT",
-                    "suggestions": [
-                        "Use format: 'owner/repo' (e.g., 'hacs/integration')",
-                        "Check the repository exists on GitHub",
-                    ],
-                })
+                raise_tool_error(
+                    create_error_response(
+                        ErrorCode.VALIDATION_INVALID_PARAMETER,
+                        "Invalid repository format. Must be 'owner/repo'",
+                        suggestions=[
+                            "Use format: 'owner/repo' (e.g., 'hacs/integration')",
+                            "Check the repository exists on GitHub",
+                        ],
+                    )
+                )
 
             # Add repository via WebSocket
             from ..client.websocket_client import get_websocket_client
+
             ws_client = await get_websocket_client()
 
             # Map user-friendly category to HACS internal name
@@ -595,14 +516,17 @@ def register_hacs_tools(mcp: Any, client: Any, **kwargs: Any) -> None:
 
             result = response.get("result", {})
 
-            return await add_timezone_metadata(client, {
-                "success": True,
-                "repository": repository,
-                "category": category,
-                "repository_id": result.get("id"),
-                "message": f"Successfully added {repository} to HACS",
-                "data": result,
-            })
+            return await add_timezone_metadata(
+                client,
+                {
+                    "success": True,
+                    "repository": repository,
+                    "category": category,
+                    "repository_id": result.get("id"),
+                    "message": f"Successfully added {repository} to HACS",
+                    "data": result,
+                },
+            )
 
         except ToolError:
             raise
@@ -623,7 +547,13 @@ def register_hacs_tools(mcp: Any, client: Any, **kwargs: Any) -> None:
                 ],
             )
 
-    @mcp.tool(tags={"HACS"}, annotations={"destructiveHint": True, "title": "Download/Install HACS Repository"})
+    @mcp.tool(
+        tags={"HACS"},
+        annotations={
+            "destructiveHint": True,
+            "title": "Download/Install HACS Repository",
+        },
+    )
     @log_tool_usage
     async def ha_hacs_download(
         repository_id: str,
@@ -642,7 +572,7 @@ def register_hacs_tools(mcp: Any, client: Any, **kwargs: Any) -> None:
 
         **Prerequisites:**
         - The repository must already be in HACS (either from the default store or added via `ha_hacs_add_repository`)
-        - Use `ha_hacs_search()` or `ha_hacs_list_installed()` to find the repository ID
+        - Use `ha_hacs_search()` to find the repository ID
 
         **Examples:**
         ```python
@@ -671,6 +601,7 @@ def register_hacs_tools(mcp: Any, client: Any, **kwargs: Any) -> None:
             await _assert_hacs_available()
 
             from ..client.websocket_client import get_websocket_client
+
             ws_client = await get_websocket_client()
 
             # If repository_id contains a slash, it's a GitHub path - need to look up numeric ID
@@ -687,16 +618,17 @@ def register_hacs_tools(mcp: Any, client: Any, **kwargs: Any) -> None:
                             repo_name = repo.get("name") or repository_id
                             break
                     else:
-                        return await add_timezone_metadata(client, {
-                            "success": False,
-                            "error": f"Repository '{repository_id}' not found in HACS",
-                            "error_code": "REPOSITORY_NOT_FOUND",
-                            "suggestions": [
-                                "Use ha_hacs_add_repository() to add the repository first",
-                                "Use ha_hacs_search() to find available repositories",
-                                "Check the repository name is correct (case-insensitive)",
-                            ],
-                        })
+                        raise_tool_error(
+                            create_error_response(
+                                ErrorCode.RESOURCE_NOT_FOUND,
+                                f"Repository '{repository_id}' not found in HACS",
+                                suggestions=[
+                                    "Use ha_hacs_add_repository() to add the repository first",
+                                    "Use ha_hacs_search() to find available repositories",
+                                    "Check the repository name is correct (case-insensitive)",
+                                ],
+                            )
+                        )
 
             # Build download command parameters
             download_kwargs: dict[str, Any] = {"repository": actual_id}
@@ -704,7 +636,9 @@ def register_hacs_tools(mcp: Any, client: Any, **kwargs: Any) -> None:
                 download_kwargs["version"] = version
 
             # Download/install the repository
-            response = await ws_client.send_command("hacs/repository/download", **download_kwargs)
+            response = await ws_client.send_command(
+                "hacs/repository/download", **download_kwargs
+            )
 
             if not response.get("success"):
                 exception_to_structured_error(
@@ -719,15 +653,19 @@ def register_hacs_tools(mcp: Any, client: Any, **kwargs: Any) -> None:
 
             result = response.get("result", {})
 
-            return await add_timezone_metadata(client, {
-                "success": True,
-                "repository_id": actual_id,
-                "repository": repo_name,
-                "version": version or "latest",
-                "message": f"Successfully installed {repo_name}" + (f" version {version}" if version else ""),
-                "note": "For integrations, restart Home Assistant to activate. For Lovelace cards, clear browser cache.",
-                "data": result,
-            })
+            return await add_timezone_metadata(
+                client,
+                {
+                    "success": True,
+                    "repository_id": actual_id,
+                    "repository": repo_name,
+                    "version": version or "latest",
+                    "message": f"Successfully installed {repo_name}"
+                    + (f" version {version}" if version else ""),
+                    "note": "For integrations, restart Home Assistant to activate. For Lovelace cards, clear browser cache.",
+                    "data": result,
+                },
+            )
 
         except ToolError:
             raise

{ha_mcp_dev-7.2.0.dev330.dist-info → ha_mcp_dev-7.2.0.dev332.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ha-mcp-dev
-Version: 7.2.0.dev330
+Version: 7.2.0.dev332
 Summary: Home Assistant MCP Server - Complete control of Home Assistant through MCP
 Author-email: Julien <github@qc-h.net>
 License: MIT
@@ -37,7 +37,7 @@ Dynamic: license-file
   <!-- mcp-name: io.github.homeassistant-ai/ha-mcp -->
 
   <p align="center">
-    <img src="https://img.shields.io/badge/tools-93-blue" alt="95+ Tools">
+    <img src="https://img.shields.io/badge/tools-91-blue" alt="95+ Tools">
     <a href="https://github.com/homeassistant-ai/ha-mcp/releases"><img src="https://img.shields.io/github/v/release/homeassistant-ai/ha-mcp" alt="Release"></a>
     <a href="https://github.com/homeassistant-ai/ha-mcp/actions/workflows/e2e-tests.yml"><img src="https://img.shields.io/github/actions/workflow/status/homeassistant-ai/ha-mcp/e2e-tests.yml?branch=master&label=E2E%20Tests" alt="E2E Tests"></a>
     <a href="LICENSE.md"><img src="https://img.shields.io/github/license/homeassistant-ai/ha-mcp.svg" alt="License"></a>
@@ -160,7 +160,7 @@ Spend less time configuring, more time enjoying your smart home.
 <details>
 <!-- TOOLS_TABLE_START -->
 
-<summary><b>Complete Tool List (93 tools)</b></summary>
+<summary><b>Complete Tool List (91 tools)</b></summary>
 
 | Category | Tools |
 |----------|-------|
@@ -175,7 +175,7 @@ Spend less time configuring, more time enjoying your smart home.
 | **Entity Registry** | `ha_get_entity_exposure`, `ha_get_entity`, `ha_remove_entity`, `ha_set_entity` |
 | **Files** | `ha_delete_file`, `ha_list_files`, `ha_read_file`, `ha_write_file` |
 | **Groups** | `ha_config_list_groups`, `ha_config_remove_group`, `ha_config_set_group` |
-| **HACS** | `ha_hacs_add_repository`, `ha_hacs_download`, `ha_hacs_info`, `ha_hacs_list_installed`, `ha_hacs_repository_info`, `ha_hacs_search` |
+| **HACS** | `ha_hacs_add_repository`, `ha_hacs_download`, `ha_hacs_repository_info`, `ha_hacs_search` |
 | **Helper Entities** | `ha_config_list_helpers`, `ha_config_remove_helper`, `ha_config_set_helper`, `ha_get_helper_schema`, `ha_set_config_entry_helper` |
 | **History & Statistics** | `ha_get_automation_traces`, `ha_get_history`, `ha_get_logs`, `ha_get_statistics` |
 | **Integrations** | `ha_delete_config_entry`, `ha_get_integration`, `ha_set_integration_enabled` |

{ha_mcp_dev-7.2.0.dev330.dist-info → ha_mcp_dev-7.2.0.dev332.dist-info}/RECORD

@@ -34,9 +34,9 @@ ha_mcp/resources/skills-vendor/skills/home-assistant-best-practices/references/h
 ha_mcp/resources/skills-vendor/skills/home-assistant-best-practices/references/safe-refactoring.md,sha256=RVkY-J-ZrBDDD3INHwbbkkPocukDgNg8eOuApswRlqk,8014
 ha_mcp/resources/skills-vendor/skills/home-assistant-best-practices/references/template-guidelines.md,sha256=rrcM8KrJ0hZw1jd4PPsVnE4rTFnsA1uA7SgltVjewkw,17856
 ha_mcp/tools/__init__.py,sha256=79ML0aicKZ5WJQn47eTPaeQntJZe1Mzt30E31_v6tXU,334
-ha_mcp/tools/backup.py,sha256=uFtzT9qM3FXt07egRbxs31uTB7-ZtfAVWPacoy-9FyQ,18395
+ha_mcp/tools/backup.py,sha256=QN0ZhLke1ItivS0ykJV74WAtsiirPduZfhIMXW4pfJc,18372
 ha_mcp/tools/best_practice_checker.py,sha256=wyeeB5L3wPFG11VX6acg7F0fz6ISbgK-5wrUhxntIPE,14576
-ha_mcp/tools/device_control.py,sha256=4PoeMyV7L1C1DirDpVxgpgjyCcaI-I2bsJJCGFzgGWA,28444
+ha_mcp/tools/device_control.py,sha256=8vI7LqcbNeJi-j4pA0GCUMOKPy8mD90IDYbEAy38_ok,28586
 ha_mcp/tools/enhanced.py,sha256=plvrTJmuAJ-55M0yznEq1Vv5TFDl_2FgegTYK7RaLC8,6668
 ha_mcp/tools/helpers.py,sha256=GveFEr0UPmnGwv18gHTkzPenrOOYtr8PT8EF8b4mmus,9504
 ha_mcp/tools/registry.py,sha256=LDU17zgJCgrlsv-yoBHm6TxAvkfnGoIdYsWfzLTmhGs,7718
@@ -53,10 +53,10 @@ ha_mcp/tools/tools_config_dashboards.py,sha256=3eQKQI-x7ESEBpVdIztp6YCZhWGl26Plj
 ha_mcp/tools/tools_config_entry_flow.py,sha256=AlDGCQxCWZPRTEyee3ak-KeDzlQM83AFNYAi-D7tS4I,21065
 ha_mcp/tools/tools_config_helpers.py,sha256=7CHDyCBsKkArZRDBf9hsNlszTGcW3bqIBOyyucBXahg,55094
 ha_mcp/tools/tools_config_scripts.py,sha256=92CJmlx5u2IQCrIPXnqIjpvDLvAbmAmWQ4EY3oGLA_A,16218
-ha_mcp/tools/tools_entities.py,sha256=aPDqXCO5EidqyIU6OTtF-X7aqNyVimwvhWm1oOpHL28,43542
+ha_mcp/tools/tools_entities.py,sha256=EgnR95p8SZatCKW4oFyhbDiIVvMte81qycZuJi_sVl4,42469
 ha_mcp/tools/tools_filesystem.py,sha256=-ZEOPD7Q4_4ULoxg2Cye8vJkdCUESHUhn1-bUHi_1_g,17846
 ha_mcp/tools/tools_groups.py,sha256=OQe3BHD8L86IAov-B6tDBkEJZIFq5p8_VmpkbfYKJ0k,14283
-ha_mcp/tools/tools_hacs.py,sha256=HwpkyC5j88y_EyeLxMmBO0rmCLf0R2f6_IdQHmcqpzc,31425
+ha_mcp/tools/tools_hacs.py,sha256=YHDwb2YzBbJLajNrfsQC-UpRjGNbQ9jOmd2lzB0aGjk,27168
 ha_mcp/tools/tools_history.py,sha256=C6a83UBaTasY-hurS_-GP00T4Ty4g43Y31B3UWLb2Sk,29568
 ha_mcp/tools/tools_integrations.py,sha256=U50nh-B99fTnYFH1TawL-a1174nQX-W01lJL5ApC5ns,17351
 ha_mcp/tools/tools_labels.py,sha256=o9ZCHY786j80zHNzn7XMTzVjdZJqeYOYC-EtS1Xhews,9868
@@ -83,12 +83,12 @@ ha_mcp/utils/fuzzy_search.py,sha256=bvT1wnGVVb2q2a4GtAnXK4uSLRU8wfGZBeGVf6CQhR0,
 ha_mcp/utils/operation_manager.py,sha256=1ETI_L2TFNhnJUUJwtuH4R0s6ZP3_rscIOfdehYSmkU,14266
 ha_mcp/utils/python_sandbox.py,sha256=mVBrBR1caQksXso3voUw2YlqY2OQJDXkt3EAZpasE0M,7488
 ha_mcp/utils/usage_logger.py,sha256=ZXbr3vHV2WT7IozrEnuNCulKt3wLXDUJI1dxaBVq0kQ,9294
-ha_mcp_dev-7.2.0.dev330.dist-info/licenses/LICENSE,sha256=7rJXXKBJWgJF8595wk-YTxwVTEi1kQaIqyy9dh5o_oY,1062
+ha_mcp_dev-7.2.0.dev332.dist-info/licenses/LICENSE,sha256=7rJXXKBJWgJF8595wk-YTxwVTEi1kQaIqyy9dh5o_oY,1062
 tests/__init__.py,sha256=YRpec-ZFYCJ48oD_7ZcNY7dB8avoTWOrZICjaM-BYJ0,39
 tests/test_constants.py,sha256=F14Pf5QMzG77RhsecaNWWaEL-B_8ykHJLIvVMcJxT8M,609
 tests/test_env_manager.py,sha256=wEYSfwmkga9IPanzVkSo03fsY77KVw71zJG5S7Kkdr8,12045
-ha_mcp_dev-7.2.0.dev330.dist-info/METADATA,sha256=EEzdQTDCouW4QKr5HCLcZokBrqntFeJOdRe6cAOZ8XI,18615
-ha_mcp_dev-7.2.0.dev330.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
-ha_mcp_dev-7.2.0.dev330.dist-info/entry_points.txt,sha256=ckO8PIrfV4-YQEyjqgO8wIzcQiMFTTJNWKZLyRtFpms,292
-ha_mcp_dev-7.2.0.dev330.dist-info/top_level.txt,sha256=cqJLEmgh4gQBKg_vBqj0ahS4DCg4J0qBXYgZCDQ2IWs,13
-ha_mcp_dev-7.2.0.dev330.dist-info/RECORD,,
+ha_mcp_dev-7.2.0.dev332.dist-info/METADATA,sha256=IapaC2pCw7BgQNDcf5JIyR65aCI3yHH1rcAVAvFMOSM,18573
+ha_mcp_dev-7.2.0.dev332.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+ha_mcp_dev-7.2.0.dev332.dist-info/entry_points.txt,sha256=ckO8PIrfV4-YQEyjqgO8wIzcQiMFTTJNWKZLyRtFpms,292
+ha_mcp_dev-7.2.0.dev332.dist-info/top_level.txt,sha256=cqJLEmgh4gQBKg_vBqj0ahS4DCg4J0qBXYgZCDQ2IWs,13
+ha_mcp_dev-7.2.0.dev332.dist-info/RECORD,,