Prepare GovOPlaN self-hosted release workflow

scripts/generate-release-catalog.py

@@ -9,11 +9,17 @@ from dataclasses import dataclass
 from datetime import UTC, datetime, timedelta
 import json
 from pathlib import Path
+import sys
 from typing import Any
 
 from cryptography.hazmat.primitives import serialization
 from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PrivateKey
 
+sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "src"))
+
+from govoplan_core.core.modules import ModuleManifest  # noqa: E402
+from govoplan_core.server.registry import available_module_manifests  # noqa: E402
+
 
 GITEA_BASE = "git+ssh://git@git.add-ideas.de/add-ideas"
 
@@ -27,6 +33,8 @@ class CatalogModule:
     description: str
     tags: tuple[str, ...]
     webui_package: str | None = None
+    provides_interfaces: tuple[dict[str, object], ...] = ()
+    requires_interfaces: tuple[dict[str, object], ...] = ()
 
 
 CATALOG_MODULES = (
@@ -225,22 +233,32 @@ def _catalog_payload(
     repository_base: str,
     public_base_url: str,
 ) -> dict[str, Any]:
+    manifests = _discovered_catalog_manifests()
     modules: list[dict[str, Any]] = []
     for module in CATALOG_MODULES:
+        manifest = manifests.get(module.module_id)
+        module_version = manifest.version if manifest is not None else version
+        module_tag = f"v{module_version.removeprefix('v')}"
         entry: dict[str, Any] = {
             "module_id": module.module_id,
             "name": module.name,
             "description": module.description,
-            "version": version,
+            "version": module_version,
             "action": "install",
             "python_package": module.python_package,
-            "python_ref": f"{module.python_package} @ {repository_base}/{module.repo}.git@{tag}",
+            "python_ref": f"{module.python_package} @ {repository_base}/{module.repo}.git@{module_tag}",
             "license_features": [f"module.{module.module_id}"],
             "tags": list(module.tags),
         }
         if module.webui_package:
             entry["webui_package"] = module.webui_package
-            entry["webui_ref"] = f"{repository_base}/{module.repo}.git#{tag}"
+            entry["webui_ref"] = f"{repository_base}/{module.repo}.git#{module_tag}"
+        manifest_interfaces = _manifest_interface_metadata(manifest)
+        entry.update(manifest_interfaces)
+        if module.provides_interfaces:
+            entry["provides_interfaces"] = [dict(item) for item in module.provides_interfaces]
+        if module.requires_interfaces:
+            entry["requires_interfaces"] = [dict(item) for item in module.requires_interfaces]
         modules.append(entry)
 
     return {
@@ -267,6 +285,38 @@ def _catalog_payload(
     }
 
 
+def _discovered_catalog_manifests() -> dict[str, ModuleManifest]:
+    try:
+        return available_module_manifests(ignore_load_errors=True)
+    except Exception:
+        return {}
+
+
+def _manifest_interface_metadata(manifest: ModuleManifest | None) -> dict[str, object]:
+    if manifest is None:
+        return {}
+    payload: dict[str, object] = {}
+    if manifest.provides_interfaces:
+        payload["provides_interfaces"] = [
+            {"name": item.name, "version": item.version}
+            for item in manifest.provides_interfaces
+        ]
+    if manifest.requires_interfaces:
+        requirements: list[dict[str, object]] = []
+        for item in manifest.requires_interfaces:
+            requirement: dict[str, object] = {
+                "name": item.name,
+                "optional": item.optional,
+            }
+            if item.version_min is not None:
+                requirement["version_min"] = item.version_min
+            if item.version_max_exclusive is not None:
+                requirement["version_max_exclusive"] = item.version_max_exclusive
+            requirements.append(requirement)
+        payload["requires_interfaces"] = requirements
+    return payload
+
+
 def _parse_signing_key(value: str) -> tuple[str, Ed25519PrivateKey]:
     key_id, separator, path_text = value.partition("=")
     if not separator or not key_id.strip() or not path_text.strip():