feat: Add v1.2.2 schema with conda package manager support

hatch_validator/core/pkg_accessor_base.py

@@ -347,3 +347,23 @@ def get_citations(self, metadata: Dict[str, Any]) -> Any:
         if self.next_accessor:
             return self.next_accessor.get_citations(metadata)
         raise NotImplementedError("Citations accessor not implemented for this schema version")
+
+    def get_python_dependency_channel(self, dependency: Dict[str, Any]) -> Any:
+        """Get channel from a Python dependency.
+
+        This method is only available for schema versions >= 1.2.2 which support
+        conda package manager with channel specification.
+
+        Args:
+            dependency (Dict[str, Any]): Python dependency object
+
+        Returns:
+            Any: Channel value (e.g., "conda-forge", "bioconda")
+
+        Raises:
+            NotImplementedError: If there is no next accessor and this method is not overridden,
+                                or if the schema version does not support channels
+        """
+        if self.next_accessor:
+            return self.next_accessor.get_python_dependency_channel(dependency)
+        raise NotImplementedError("Python dependency channel accessor not implemented for this schema version")

hatch_validator/core/pkg_accessor_factory.py

@@ -70,6 +70,12 @@ def _ensure_accessors_loaded(cls) -> None:
             except ImportError as e:
                 logger.warning(f"Could not load v1.2.1 accessor: {e}")
 
+            try:
+                from hatch_validator.package.v1_2_2.accessor import HatchPkgAccessor as V122HatchPkgAccessor
+                cls.register_accessor("1.2.2", V122HatchPkgAccessor)
+            except ImportError as e:
+                logger.warning(f"Could not load v1.2.2 accessor: {e}")
+
     @classmethod
     def create_accessor_chain(cls, target_version: Optional[str] = None) -> HatchPkgAccessor:
         """Create appropriate accessor chain based on target version.

hatch_validator/core/validator_factory.py

@@ -72,6 +72,12 @@ def _ensure_validators_loaded(cls) -> None:
                 cls.register_validator("1.2.1", V121Validator)
             except ImportError as e:
                 logger.warning(f"Could not load v1.2.1 validator: {e}")
+
+            try:
+                from hatch_validator.package.v1_2_2.validator import Validator as V122Validator
+                cls.register_validator("1.2.2", V122Validator)
+            except ImportError as e:
+                logger.warning(f"Could not load v1.2.2 validator: {e}")
 
     @classmethod
     def create_validator_chain(cls, target_version: Optional[str] = None) -> Validator:

hatch_validator/package/package_service.py

@@ -160,3 +160,23 @@ def get_tools(self) -> Any:
         if not self.is_loaded():
             raise ValueError("Package metadata is not loaded.")
         return self._accessor.get_tools(self._metadata)
+
+    def get_python_dependency_channel(self, dependency: Dict[str, Any]) -> Any:
+        """Get channel from a Python dependency.
+
+        This method is only available for schema versions >= 1.2.2 which support
+        conda package manager with channel specification.
+
+        Args:
+            dependency (Dict[str, Any]): Python dependency object
+
+        Returns:
+            Any: Channel value (e.g., "conda-forge", "bioconda"), or None if not specified
+
+        Raises:
+            ValueError: If metadata is not loaded.
+            NotImplementedError: If the schema version does not support channels.
+        """
+        if not self.is_loaded():
+            raise ValueError("Package metadata is not loaded.")
+        return self._accessor.get_python_dependency_channel(dependency)

hatch_validator/package/v1_2_1/accessor.py

@@ -30,26 +30,31 @@ def can_handle(self, schema_version: str) -> bool:
         return schema_version == "1.2.1"
 
     def get_entry_point(self, metadata):
-        """From v1.2.1, returns the same as get_mcp_entry_point().
+        """Get the full entry point dict for v1.2.1.
+
+        In v1.2.1, entry_point is a dict with mcp_server and hatch_mcp_server keys.
+        This method returns the full dict to maintain backward compatibility with
+        code that expects to access both entry points.
 
         Args:
             metadata (dict): Package metadata
 
         Returns:
-            Any: Dual entry point value
+            dict: Dual entry point dict with mcp_server and hatch_mcp_server keys
         """
-        return metadata.get('entry_point').get('mcp_server')
-    
+        return metadata.get('entry_point', {})
+
     def get_mcp_entry_point(self, metadata):
         """Get MCP entry point from metadata.
 
         Args:
             metadata (dict): Package metadata
 
         Returns:
-            Any: MCP entry point value
+            str: MCP entry point value (e.g., "mcp_server.py")
         """
-        return self.get_entry_point(metadata)
+        entry_point = metadata.get('entry_point', {})
+        return entry_point.get('mcp_server') if isinstance(entry_point, dict) else None
 
     def get_hatch_mcp_entry_point(self, metadata):
         """Get Hatch MCP entry point from metadata.

hatch_validator/package/v1_2_2/__init__.py

@@ -0,0 +1,6 @@
+"""Schema validation package for v1.2.2.
+
+This package contains the validator and strategies for schema version 1.2.2,
+which introduces conda package manager support for Python dependencies.
+"""
+

hatch_validator/package/v1_2_2/accessor.py

@@ -0,0 +1,47 @@
+"""Package metadata accessor for schema version 1.2.2.
+
+This module provides the metadata accessor for schema version 1.2.2,
+which introduces conda package manager support for Python dependencies.
+All metadata access patterns remain unchanged from v1.2.1, except for
+the new channel field in Python dependencies.
+"""
+
+import logging
+from typing import Dict, Any
+from hatch_validator.core.pkg_accessor_base import HatchPkgAccessor as HatchPkgAccessorBase
+
+logger = logging.getLogger("hatch.package.v1_2_2.accessor")
+
+class HatchPkgAccessor(HatchPkgAccessorBase):
+    """Metadata accessor for Hatch package schema version 1.2.2.
+
+    Schema version 1.2.2 introduces conda package manager support for Python
+    dependencies with optional channel specification. This accessor implements
+    the channel accessor while delegating all other operations to v1.2.1.
+    """
+
+    def can_handle(self, schema_version: str) -> bool:
+        """Check if this accessor can handle schema version 1.2.2.
+
+        Args:
+            schema_version (str): Schema version to check
+
+        Returns:
+            bool: True if schema_version is '1.2.2'
+        """
+        return schema_version == "1.2.2"
+
+    def get_python_dependency_channel(self, dependency: Dict[str, Any]) -> Any:
+        """Get channel from a Python dependency.
+
+        This method retrieves the channel field from a Python dependency,
+        which is available in schema version 1.2.2 for conda packages.
+
+        Args:
+            dependency (Dict[str, Any]): Python dependency object
+
+        Returns:
+            Any: Channel value (e.g., "conda-forge", "bioconda"), or None if not specified
+        """
+        return dependency.get('channel')
+