ha-mcp-dev 7.2.0.dev363__tar.gz → 7.2.0.dev365__tar.gz

{ha_mcp_dev-7.2.0.dev363/src/ha_mcp_dev.egg-info → ha_mcp_dev-7.2.0.dev365}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ha-mcp-dev
-Version: 7.2.0.dev363
+Version: 7.2.0.dev365
 Summary: Home Assistant MCP Server - Complete control of Home Assistant through MCP
 Author-email: Julien <github@qc-h.net>
 License: MIT

{ha_mcp_dev-7.2.0.dev363 → ha_mcp_dev-7.2.0.dev365}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ha-mcp-dev"
-version = "7.2.0.dev363"
+version = "7.2.0.dev365"
 description = "Home Assistant MCP Server - Complete control of Home Assistant through MCP"
 readme = "README.md"
 requires-python = ">=3.13,<3.14"

{ha_mcp_dev-7.2.0.dev363 → ha_mcp_dev-7.2.0.dev365}/src/ha_mcp/tools/tools_config_automations.py

@@ -13,10 +13,18 @@ from fastmcp.tools import tool
 from pydantic import Field
 
 from ..errors import (
+    ErrorCode,
     create_config_error,
+    create_error_response,
     create_resource_not_found_error,
     create_validation_error,
 )
+from ..utils.config_hash import compute_config_hash
+from ..utils.python_sandbox import (
+    PythonSandboxError,
+    get_security_documentation,
+    safe_execute,
+)
 from .best_practice_checker import (
     check_automation_config as _check_best_practices,
 )
@@ -244,11 +252,10 @@ class AutomationConfigTools:
         For comprehensive automation documentation, use ha_get_skill_home_assistant_best_practices.
         """
         try:
-            config_result = await self._client.get_automation_config(identifier)
-            # Normalize config for round-trip compatibility (GET -> SET)
-            normalized_config = _normalize_config_for_roundtrip(config_result)
+            normalized_config, config_hash = await self._get_automation_config_internal(identifier)
 
             # Resolve entity_id and fetch category from entity registry
+            # (injected after hash so transient registry failures don't affect the hash)
             entity_id = await self._resolve_automation_entity_id(identifier)
             if entity_id:
                 cat_id = await fetch_entity_category(self._client, entity_id, "automation")
@@ -260,6 +267,7 @@ class AutomationConfigTools:
                 "action": "get",
                 "identifier": identifier,
                 "config": normalized_config,
+                "config_hash": config_hash,
             }
         except Exception as e:
             # Handle 404 errors gracefully (often used to verify deletion)
@@ -304,18 +312,44 @@ class AutomationConfigTools:
     async def ha_config_set_automation(
         self,
         config: Annotated[
-            str | dict[str, Any],
+            str | dict[str, Any] | None,
             Field(
-                description="Complete automation configuration with required fields: 'alias', 'trigger', 'action'. Optional: 'description', 'condition', 'mode', 'max', 'initial_state', 'variables'"
+                description="Complete automation configuration with required fields: 'alias', 'trigger', 'action'. "
+                "Optional: 'description', 'condition', 'mode', 'max', 'initial_state', 'variables'. "
+                "Mutually exclusive with python_transform.",
+                default=None,
             ),
-        ],
+        ] = None,
         identifier: Annotated[
             str | None,
             Field(
-                description="Automation entity_id or unique_id for updates. Omit to create new automation with generated unique_id.",
+                description="Automation entity_id or unique_id for updates. "
+                "Required for python_transform. Omit to create new automation with generated unique_id.",
                 default=None,
             ),
         ] = None,
+        python_transform: Annotated[
+            str | None,
+            Field(
+                description="Python expression to transform existing automation config. "
+                "Mutually exclusive with config. "
+                "Requires identifier and config_hash for validation. "
+                "WARNING: Expressions with infinite loops will hang the server. "
+                "Examples: "
+                "Simple: python_transform=\"config['action'][0]['data']['brightness'] = 255\" "
+                "Pattern: python_transform=\"for a in config['action']: "
+                "if a.get('alias') == 'My Step': a['data']['value'] = 100\" "
+                "\n\n" + get_security_documentation(),
+            ),
+        ] = None,
+        config_hash: Annotated[
+            str | None,
+            Field(
+                description="Config hash from ha_config_get_automation for optimistic locking. "
+                "REQUIRED for python_transform (validates automation unchanged). "
+                "Optional for config updates (validates before full replacement if provided).",
+            ),
+        ] = None,
         category: Annotated[
             str | None,
             Field(
@@ -334,6 +368,19 @@ class AutomationConfigTools:
         """
         Create or update a Home Assistant automation.
 
+        Supports two modes: full config replacement OR Python transformation.
+
+        WHEN TO USE WHICH MODE:
+        - python_transform: RECOMMENDED for edits to existing automations. Surgical updates.
+        - config: Use for creating new automations or full restructures.
+
+        IMPORTANT: python_transform requires 'identifier' and 'config_hash' from ha_config_get_automation().
+
+        PYTHON TRANSFORM EXAMPLES:
+        - Update action: python_transform="config['action'][0]['data']['brightness'] = 255"
+        - Add trigger: python_transform="config['trigger'].append({'platform': 'state', 'entity_id': 'binary_sensor.motion', 'to': 'on'})"
+        - Remove last action: python_transform="config['action'].pop()"
+
         Creates a new automation (if identifier omitted) or updates existing automation with provided configuration.
 
         AUTOMATION TYPES:
@@ -452,6 +499,126 @@ class AutomationConfigTools:
         """
         bp_warnings: list[str] = []
         try:
+            # Validate mutual exclusivity of config and python_transform
+            if config is not None and python_transform is not None:
+                raise_tool_error(
+                    create_error_response(
+                        ErrorCode.VALIDATION_INVALID_PARAMETER,
+                        "Cannot use both config and python_transform simultaneously",
+                        suggestions=[
+                            "Use only ONE of: config or python_transform",
+                            "config: Full replacement",
+                            "python_transform: Python-based edits (recommended for existing automations)",
+                        ],
+                        context={"action": "set", "identifier": identifier},
+                    )
+                )
+
+            # Handle python_transform mode
+            if python_transform is not None:
+                if not identifier:
+                    raise_tool_error(
+                        create_error_response(
+                            ErrorCode.VALIDATION_INVALID_PARAMETER,
+                            "identifier is required for python_transform",
+                            suggestions=[
+                                "Provide the automation entity_id or unique_id",
+                                "Use ha_search_entities(domain_filter='automation') to find automations",
+                            ],
+                            context={"action": "python_transform", "identifier": identifier},
+                        )
+                    )
+                if config_hash is None:
+                    raise_tool_error(
+                        create_error_response(
+                            ErrorCode.VALIDATION_INVALID_PARAMETER,
+                            "config_hash is required for python_transform",
+                            suggestions=[
+                                "Call ha_config_get_automation() first",
+                                "Use the config_hash from that response",
+                            ],
+                            context={"action": "python_transform", "identifier": identifier},
+                        )
+                    )
+
+                # Fetch current config and verify hash
+                current_config = await self._fetch_and_verify_hash(
+                    identifier, config_hash, "python_transform"
+                )
+
+                # Apply Python transformation
+                try:
+                    transformed_config = safe_execute(python_transform, current_config)
+                except PythonSandboxError as e:
+                    raise_tool_error(
+                        create_error_response(
+                            ErrorCode.VALIDATION_FAILED,
+                            str(e),
+                            suggestions=[
+                                "Check expression syntax",
+                                "Ensure only allowed operations are used",
+                                "See tool description for allowed operations",
+                                f"Expression: {python_transform[:100]}{'...' if len(python_transform) > 100 else ''}",
+                            ],
+                            context={"action": "python_transform", "identifier": identifier},
+                        )
+                    )
+
+                # Pop category before sending to HA REST API (rejects unknown keys)
+                transform_category = transformed_config.pop("category", None)
+
+                # Normalize and validate the transformed config
+                transformed_config = _normalize_automation_config(transformed_config)
+                self._validate_required_fields(transformed_config, identifier)
+                bp_warnings = _check_best_practices(
+                    transformed_config, skill_prefix=_get_skill_prefix()
+                )
+
+                # Save transformed config
+                result = await self._client.upsert_automation_config(
+                    transformed_config, identifier
+                )
+
+                # Re-fetch to get authoritative hash (HA may normalize after save)
+                refetched = await self._get_automation_config_internal(identifier)
+                new_config_hash = refetched[1]  # (config, hash) tuple
+
+                # Re-apply category if present
+                entity_id = result.get("entity_id")
+                if not entity_id and identifier and identifier.startswith("automation."):
+                    entity_id = identifier
+                if transform_category and entity_id:
+                    await apply_entity_category(
+                        self._client, entity_id, transform_category, "automation", result, "automation"
+                    )
+
+                response: dict[str, Any] = {
+                    "success": True,
+                    "action": "python_transform",
+                    "identifier": identifier,
+                    "config_hash": new_config_hash,
+                    "python_expression": python_transform,
+                    "message": f"Automation {identifier} updated via Python transform",
+                    # Merge upsert result, excluding "success" (we set it ourselves)
+                    **{k: v for k, v in result.items() if k != "success"},
+                }
+                if bp_warnings:
+                    response["best_practice_warnings"] = bp_warnings
+                return response
+
+            if config is None:
+                raise_tool_error(
+                    create_error_response(
+                        ErrorCode.VALIDATION_INVALID_PARAMETER,
+                        "Either config or python_transform must be provided",
+                        suggestions=[
+                            "config: Full automation configuration for create/replace",
+                            "python_transform: Python expression for surgical edits",
+                        ],
+                        context={"action": "set", "identifier": identifier},
+                    )
+                )
+
             config_dict = self._parse_and_validate_config(config)
 
             # Extract category before sending to HA REST API (which rejects unknown keys).
@@ -462,6 +629,10 @@ class AutomationConfigTools:
             # Normalize field names (triggers -> trigger, actions -> action, etc.)
             config_dict = _normalize_automation_config(config_dict)
 
+            # Optional hash check for full config updates
+            if identifier and config_hash:
+                await self._fetch_and_verify_hash(identifier, config_hash, "set")
+
             # Validate required fields based on automation type
             self._validate_required_fields(config_dict, identifier)
 
@@ -533,6 +704,42 @@ class AutomationConfigTools:
                 suggestions=suggestions,
             )
 
+    async def _get_automation_config_internal(
+        self, identifier: str
+    ) -> tuple[dict[str, Any], str]:
+        """Fetch and normalize automation config without logging or category injection.
+
+        Returns (normalized_config, config_hash) tuple.
+        Used internally by _fetch_and_verify_hash and ha_config_get_automation.
+        """
+        config_result = await self._client.get_automation_config(identifier)
+        normalized_config = _normalize_config_for_roundtrip(config_result)
+        config_hash_value = compute_config_hash(normalized_config)
+        return normalized_config, config_hash_value
+
+    async def _fetch_and_verify_hash(
+        self, identifier: str, config_hash: str, action: str
+    ) -> dict[str, Any]:
+        """Fetch current automation config and verify config_hash for optimistic locking.
+
+        Returns the current normalized config dict.
+        Raises ToolError if the hash does not match (conflict).
+        """
+        current_config, current_hash = await self._get_automation_config_internal(identifier)
+        if current_hash != config_hash:
+            raise_tool_error(
+                create_error_response(
+                    ErrorCode.SERVICE_CALL_FAILED,
+                    "Automation modified since last read (conflict)",
+                    suggestions=[
+                        "Call ha_config_get_automation() again",
+                        "Use the fresh config_hash from that response",
+                    ],
+                    context={"action": action, "identifier": identifier},
+                )
+            )
+        return current_config
+
     @staticmethod
     def _parse_and_validate_config(config: str | dict[str, Any]) -> dict[str, Any]:
         """Parse JSON config and validate it is a dict."""

{ha_mcp_dev-7.2.0.dev363 → ha_mcp_dev-7.2.0.dev365}/src/ha_mcp/tools/tools_config_dashboards.py

@@ -4,7 +4,6 @@ Configuration management tools for Home Assistant Lovelace dashboards.
 This module provides tools for managing dashboard metadata and content.
 """
 
-import hashlib
 import json
 import logging
 import re
@@ -14,6 +13,7 @@ from fastmcp.exceptions import ToolError
 from pydantic import Field
 
 from ..errors import ErrorCode, create_error_response, create_resource_not_found_error
+from ..utils.config_hash import compute_config_hash
 from ..utils.python_sandbox import (
     PythonSandboxError,
     get_security_documentation,
@@ -26,13 +26,6 @@ logger = logging.getLogger(__name__)
 
 
 
-def _compute_config_hash(config: dict[str, Any]) -> str:
-    """Compute a stable hash of dashboard config for optimistic locking."""
-    # Use sorted keys for deterministic serialization
-    config_str = json.dumps(config, sort_keys=True, separators=(",", ":"))
-    return hashlib.sha256(config_str.encode()).hexdigest()[:16]
-
-
 async def _verify_config_unchanged(
     client: Any,
     url_path: str,
@@ -59,7 +52,7 @@ async def _verify_config_unchanged(
     if not isinstance(current_config, dict):
         return {"success": True}  # Can't verify, proceed anyway
 
-    current_hash = _compute_config_hash(current_config)
+    current_hash = compute_config_hash(current_config)
 
     if current_hash != original_hash:
         raise_tool_error(
@@ -433,7 +426,7 @@ def register_config_dashboard_tools(mcp: Any, client: Any, **kwargs: Any) -> Non
                     for match in matches:
                         del match["card_config"]
 
-                config_hash: str | None = _compute_config_hash(config)
+                config_hash: str | None = compute_config_hash(config)
 
                 return {
                     "success": True,
@@ -486,7 +479,7 @@ def register_config_dashboard_tools(mcp: Any, client: Any, **kwargs: Any) -> Non
 
             # Compute hash for optimistic locking in subsequent operations
             config_hash = (
-                _compute_config_hash(config) if isinstance(config, dict) else None
+                compute_config_hash(config) if isinstance(config, dict) else None
             )
 
             # Calculate config size for progressive disclosure hint
@@ -832,7 +825,7 @@ def register_config_dashboard_tools(mcp: Any, client: Any, **kwargs: Any) -> Non
                     )
 
                 # Validate config_hash for optimistic locking
-                current_hash = _compute_config_hash(current_config)
+                current_hash = compute_config_hash(current_config)
                 if current_hash != config_hash:
                     raise_tool_error(
                         create_error_response(
@@ -902,7 +895,7 @@ def register_config_dashboard_tools(mcp: Any, client: Any, **kwargs: Any) -> Non
                     )
 
                 # Compute new hash for potential chaining
-                new_config_hash = _compute_config_hash(transformed_config)
+                new_config_hash = compute_config_hash(transformed_config)
 
                 return {
                     "success": True,
@@ -1072,7 +1065,7 @@ def register_config_dashboard_tools(mcp: Any, client: Any, **kwargs: Any) -> Non
 
                         # Optional config_hash validation for full replacement
                         if config_hash is not None:
-                            current_hash = _compute_config_hash(current_config)
+                            current_hash = compute_config_hash(current_config)
                             if current_hash != config_hash:
                                 raise_tool_error(
                                     create_error_response(

{ha_mcp_dev-7.2.0.dev363 → ha_mcp_dev-7.2.0.dev365}/src/ha_mcp/tools/tools_config_scripts.py

@@ -13,6 +13,12 @@ from fastmcp.tools import tool
 from pydantic import Field
 
 from ..errors import ErrorCode, create_error_response
+from ..utils.config_hash import compute_config_hash
+from ..utils.python_sandbox import (
+    PythonSandboxError,
+    get_security_documentation,
+    safe_execute,
+)
 from .best_practice_checker import (
     check_script_config as _check_best_practices,
 )
@@ -95,8 +101,12 @@ class ConfigScriptTools:
         """
         try:
             config_result = await self._client.get_script_config(script_id)
+            # Extract actual script config body and compute hash before category injection
+            actual_config = config_result.get("config", config_result)
+            config_hash_value = compute_config_hash(actual_config)
 
             # Fetch category from entity registry (best-effort)
+            # (injected after hash so transient registry failures don't affect the hash)
             entity_id = f"script.{script_id}"
             cat_id = await fetch_entity_category(self._client, entity_id, "script")
             if cat_id:
@@ -107,6 +117,7 @@ class ConfigScriptTools:
                 "action": "get",
                 "script_id": script_id,
                 "config": config_result,
+                "config_hash": config_hash_value,
             }
         except ToolError:
             raise
@@ -121,6 +132,43 @@ class ConfigScriptTools:
                 ],
             )
 
+    async def _get_script_config_internal(
+        self, script_id: str
+    ) -> tuple[dict[str, Any], str]:
+        """Fetch script config without logging or category injection.
+
+        Returns (actual_config, config_hash) tuple where actual_config is
+        the inner script body (not the REST wrapper).
+        Used internally by _fetch_and_verify_hash and ha_config_get_script.
+        """
+        config_result = await self._client.get_script_config(script_id)
+        actual_config = config_result.get("config", config_result)
+        config_hash_value = compute_config_hash(actual_config)
+        return actual_config, config_hash_value
+
+    async def _fetch_and_verify_hash(
+        self, script_id: str, config_hash: str, action: str
+    ) -> dict[str, Any]:
+        """Fetch current script config and verify config_hash for optimistic locking.
+
+        Returns the actual script config dict (inner body).
+        Raises ToolError if the hash does not match (conflict).
+        """
+        actual_config, current_hash = await self._get_script_config_internal(script_id)
+        if current_hash != config_hash:
+            raise_tool_error(
+                create_error_response(
+                    ErrorCode.SERVICE_CALL_FAILED,
+                    "Script modified since last read (conflict)",
+                    suggestions=[
+                        "Call ha_config_get_script() again",
+                        "Use the fresh config_hash from that response",
+                    ],
+                    context={"action": action, "script_id": script_id},
+                )
+            )
+        return actual_config
+
     @staticmethod
     def _validate_script_config(
         config: str | dict[str, Any],
@@ -187,11 +235,36 @@ class ConfigScriptTools:
             str, Field(description="Script identifier (e.g., 'morning_routine')")
         ],
         config: Annotated[
-            str | dict[str, Any],
+            str | dict[str, Any] | None,
             Field(
-                description="Script configuration dictionary. Must include EITHER 'sequence' (for regular scripts) OR 'use_blueprint' (for blueprint-based scripts). Optional fields: 'alias', 'description', 'icon', 'mode', 'max', 'fields'"
+                description="Script configuration dictionary. Must include EITHER 'sequence' (for regular scripts) OR 'use_blueprint' (for blueprint-based scripts). "
+                "Optional fields: 'alias', 'description', 'icon', 'mode', 'max', 'fields'. "
+                "Mutually exclusive with python_transform.",
+                default=None,
             ),
-        ],
+        ] = None,
+        python_transform: Annotated[
+            str | None,
+            Field(
+                description="Python expression to transform existing script config. "
+                "Mutually exclusive with config. "
+                "Requires config_hash for validation. "
+                "WARNING: Expressions with infinite loops will hang the server. "
+                "Examples: "
+                "Simple: python_transform=\"config['sequence'][0]['data']['message'] = 'Hello'\" "
+                "Pattern: python_transform=\"for step in config['sequence']: "
+                "if step.get('alias') == 'My Step': step['data']['value'] = 100\" "
+                "\n\n" + get_security_documentation(),
+            ),
+        ] = None,
+        config_hash: Annotated[
+            str | None,
+            Field(
+                description="Config hash from ha_config_get_script for optimistic locking. "
+                "REQUIRED for python_transform (validates script unchanged). "
+                "Optional for config updates (validates before full replacement if provided).",
+            ),
+        ] = None,
         category: Annotated[
             str | None,
             Field(
@@ -210,6 +283,19 @@ class ConfigScriptTools:
         """
         Create or update a Home Assistant script.
 
+        Supports two modes: full config replacement OR Python transformation.
+
+        WHEN TO USE WHICH MODE:
+        - python_transform: RECOMMENDED for edits to existing scripts. Surgical updates.
+        - config: Use for creating new scripts or full restructures.
+
+        IMPORTANT: python_transform requires 'config_hash' from ha_config_get_script().
+
+        PYTHON TRANSFORM EXAMPLES:
+        - Update step: python_transform="config['sequence'][0]['data']['message'] = 'Hello'"
+        - Add step: python_transform="config['sequence'].append({'delay': {'seconds': 5}})"
+        - Remove last step: python_transform="config['sequence'].pop()"
+
         Creates a new script or updates an existing one with the provided configuration.
         Supports both regular scripts (with sequence) and blueprint-based scripts.
 
@@ -319,10 +405,119 @@ class ConfigScriptTools:
         """
         bp_warnings: list[str] = []
         try:
+            # Validate mutual exclusivity of config and python_transform
+            if config is not None and python_transform is not None:
+                raise_tool_error(
+                    create_error_response(
+                        ErrorCode.VALIDATION_INVALID_PARAMETER,
+                        "Cannot use both config and python_transform simultaneously",
+                        suggestions=[
+                            "Use only ONE of: config or python_transform",
+                            "config: Full replacement",
+                            "python_transform: Python-based edits (recommended for existing scripts)",
+                        ],
+                        context={"action": "set", "script_id": script_id},
+                    )
+                )
+
+            # Handle python_transform mode
+            if python_transform is not None:
+                if config_hash is None:
+                    raise_tool_error(
+                        create_error_response(
+                            ErrorCode.VALIDATION_INVALID_PARAMETER,
+                            "config_hash is required for python_transform",
+                            suggestions=[
+                                "Call ha_config_get_script() first",
+                                "Use the config_hash from that response",
+                            ],
+                            context={"action": "python_transform", "script_id": script_id},
+                        )
+                    )
+
+                # Fetch current config and verify hash
+                actual_config = await self._fetch_and_verify_hash(
+                    script_id, config_hash, "python_transform"
+                )
+
+                # Apply Python transformation on the actual script config
+                try:
+                    transformed_config = safe_execute(python_transform, actual_config)
+                except PythonSandboxError as e:
+                    raise_tool_error(
+                        create_error_response(
+                            ErrorCode.VALIDATION_FAILED,
+                            str(e),
+                            suggestions=[
+                                "Check expression syntax",
+                                "Ensure only allowed operations are used",
+                                "See tool description for allowed operations",
+                                f"Expression: {python_transform[:100]}{'...' if len(python_transform) > 100 else ''}",
+                            ],
+                            context={"action": "python_transform", "script_id": script_id},
+                        )
+                    )
+
+                # Validate transformed config
+                if "sequence" not in transformed_config and "use_blueprint" not in transformed_config:
+                    raise_tool_error(
+                        create_error_response(
+                            ErrorCode.VALIDATION_FAILED,
+                            "Transformed config must include either 'sequence' or 'use_blueprint'",
+                            suggestions=[
+                                "The transform may have removed required fields",
+                                "Ensure the config still has a 'sequence' or 'use_blueprint' key",
+                            ],
+                            context={"action": "python_transform", "script_id": script_id},
+                        )
+                    )
+                bp_warnings = _check_best_practices(
+                    transformed_config, skill_prefix=_get_skill_prefix()
+                )
+
+                # Save transformed config
+                result = await self._client.upsert_script_config(
+                    transformed_config, script_id
+                )
+
+                # Re-fetch to get authoritative hash (HA may normalize after save)
+                _, new_config_hash = await self._get_script_config_internal(script_id)
+
+                response: dict[str, Any] = {
+                    "success": True,
+                    "action": "python_transform",
+                    "script_id": script_id,
+                    "config_hash": new_config_hash,
+                    "python_expression": python_transform,
+                    "message": f"Script {script_id} updated via Python transform",
+                    # Merge upsert result, excluding "success" (we set it ourselves)
+                    **{k: v for k, v in result.items() if k != "success"},
+                }
+                if bp_warnings:
+                    response["best_practice_warnings"] = bp_warnings
+                return response
+
+            if config is None:
+                raise_tool_error(
+                    create_error_response(
+                        ErrorCode.VALIDATION_INVALID_PARAMETER,
+                        "Either config or python_transform must be provided",
+                        suggestions=[
+                            "config: Full script configuration for create/replace",
+                            "python_transform: Python expression for surgical edits",
+                        ],
+                        context={"action": "set", "script_id": script_id},
+                    )
+                )
+
             config_dict, effective_category = self._validate_script_config(
                 config, script_id, category,
             )
 
+            # Optional hash check for full config updates
+            if config_hash:
+                await self._fetch_and_verify_hash(script_id, config_hash, "set")
+
             # Pre-check for best-practice issues.
             bp_warnings = _check_best_practices(
                 config_dict, skill_prefix=_get_skill_prefix()

{ha_mcp_dev-7.2.0.dev363 → ha_mcp_dev-7.2.0.dev365}/src/ha_mcp/tools/tools_history.py

@@ -194,7 +194,7 @@ class HistoryTools:
         period: Annotated[
             str,
             Field(
-                description='Aggregation period: "5minute", "hour", "day", "week", "month". Default: "day". Ignored when source="history"',
+                description='Aggregation period: "5minute", "hour", "day", "week", "month", "year". Default: "day". Ignored when source="history"',
                 default="day",
             ),
         ] = "day",
@@ -580,7 +580,7 @@ async def _fetch_statistics(
         ))
 
     # Validate period
-    valid_periods = ["5minute", "hour", "day", "week", "month"]
+    valid_periods = ["5minute", "hour", "day", "week", "month", "year"]
     if period not in valid_periods:
         raise_tool_error(create_error_response(
             ErrorCode.VALIDATION_INVALID_PARAMETER,

ha_mcp_dev-7.2.0.dev365/src/ha_mcp/utils/config_hash.py

@@ -0,0 +1,18 @@
+"""Shared config hash utility for optimistic locking.
+
+Used by automation, script, and dashboard tools to detect concurrent modifications.
+"""
+
+import hashlib
+import json
+from typing import Any
+
+
+def compute_config_hash(config: dict[str, Any]) -> str:
+    """Compute a stable hash of a config dict for optimistic locking.
+
+    Uses SHA256 truncated to 16 hex characters (64 bits). Deterministic
+    via sorted keys and minimal separators.
+    """
+    config_str = json.dumps(config, sort_keys=True, separators=(",", ":"))
+    return hashlib.sha256(config_str.encode()).hexdigest()[:16]

{ha_mcp_dev-7.2.0.dev363 → ha_mcp_dev-7.2.0.dev365/src/ha_mcp_dev.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ha-mcp-dev
-Version: 7.2.0.dev363
+Version: 7.2.0.dev365
 Summary: Home Assistant MCP Server - Complete control of Home Assistant through MCP
 Author-email: Julien <github@qc-h.net>
 License: MIT

{ha_mcp_dev-7.2.0.dev363 → ha_mcp_dev-7.2.0.dev365}/src/ha_mcp_dev.egg-info/SOURCES.txt

@@ -82,6 +82,7 @@ src/ha_mcp/tools/util_helpers.py
 src/ha_mcp/transforms/__init__.py
 src/ha_mcp/transforms/categorized_search.py
 src/ha_mcp/utils/__init__.py
+src/ha_mcp/utils/config_hash.py
 src/ha_mcp/utils/domain_handlers.py
 src/ha_mcp/utils/fuzzy_search.py
 src/ha_mcp/utils/operation_manager.py