@qingflow-tech/qingflow-cli 1.1.43-beta.3 → 1.1.43-beta.5

package/src/qingflow_mcp/builder_facade/app_form_schema.py

@@ -5,7 +5,7 @@ from dataclasses import dataclass
 import json
 import os
 from pathlib import Path
-from typing import Any
+from typing import Any, Iterable
 
 from jsonschema import Draft202012Validator, FormatChecker
 
@@ -14,6 +14,116 @@ JSONObject = dict[str, Any]
 SCHEMA_ROOT = Path(__file__).with_name("schemas") / "app_form"
 
 
+def _discriminator_score(schema: Any, instance: Any, root_schema: Any = None, seen_refs: set[str] | None = None) -> int:
+    """Score a schema branch against its input discriminator values."""
+    if not isinstance(schema, dict) or not isinstance(instance, dict):
+        return 0
+    reference = schema.get("$ref")
+    if isinstance(reference, str) and reference.startswith("#/") and isinstance(root_schema, dict):
+        seen_refs = seen_refs or set()
+        if reference in seen_refs:
+            return 0
+        target: Any = root_schema
+        for part in reference[2:].split("/"):
+            if not isinstance(target, dict):
+                return 0
+            target = target.get(part.replace("~1", "/").replace("~0", "~"))
+        return _discriminator_score(target, instance, root_schema, seen_refs | {reference})
+    score = 0
+    properties = schema.get("properties")
+    if isinstance(properties, dict):
+        for key, constraint in properties.items():
+            if not isinstance(constraint, dict) or key not in instance:
+                continue
+            value = instance.get(key)
+            if "const" in constraint:
+                score += 3 if value == constraint["const"] else -3
+            elif isinstance(constraint.get("enum"), list):
+                score += 3 if value in constraint["enum"] else -3
+    for combinator in ("allOf", "anyOf", "oneOf"):
+        children = schema.get(combinator)
+        if not isinstance(children, list):
+            continue
+        child_scores = [_discriminator_score(child, instance, root_schema, seen_refs) for child in children]
+        if combinator == "allOf":
+            score += sum(child_score for child_score in child_scores if child_score > 0)
+        elif child_scores:
+            score += max(child_scores)
+    return score
+
+
+def _selected_combinator_children(error: Any, root_schema: Any = None) -> list[Any] | None:
+    """Return errors from the branch matching a known discriminator.
+
+    jsonschema flattens errors from nested ``allOf`` branches into the parent
+    combinator context, so branch identity is recovered from the schema path.
+    """
+    if not isinstance(error.schema, dict):
+        return None
+    branches = error.schema.get(error.validator)
+    if not isinstance(branches, list) or not branches:
+        return None
+    scores = [_discriminator_score(branch, error.instance, root_schema) for branch in branches]
+    best = max(scores)
+    if best <= 0:
+        return None
+    selected = {index for index, score in enumerate(scores) if score == best}
+    prefix = tuple(error.absolute_schema_path)
+    children = [
+        child
+        for child in error.context
+        if len(tuple(child.absolute_schema_path)) > len(prefix)
+        and tuple(child.absolute_schema_path)[: len(prefix)] == prefix
+        and tuple(child.absolute_schema_path)[len(prefix)] in selected
+    ]
+    return children or None
+
+
+def _iter_compact_schema_errors(error: Any, root_schema: Any = None) -> Iterable[Any]:
+    if error.validator in {"oneOf", "anyOf"}:
+        selected = _selected_combinator_children(error, root_schema)
+        if selected:
+            for child in selected:
+                yield from _iter_compact_schema_errors(child, root_schema)
+            return
+        yield error
+        return
+    if error.context:
+        for child in error.context:
+            yield from _iter_compact_schema_errors(child, root_schema)
+        return
+    yield error
+
+
+def compact_schema_errors(errors: Iterable[Any], root_schema: Any = None) -> list[Any]:
+    """Collapse polymorphic-schema noise while retaining actionable errors."""
+    flattened = [leaf for error in errors for leaf in _iter_compact_schema_errors(error, root_schema)]
+    descendant_paths = [tuple(error.absolute_path) for error in flattened]
+    result: list[Any] = []
+    seen: set[tuple[tuple[Any, ...], str, str]] = set()
+    for error in flattened:
+        path = tuple(error.absolute_path)
+        if error.validator == "unevaluatedProperties" and any(
+            len(other) > len(path) and other[: len(path)] == path for other in descendant_paths
+        ):
+            continue
+        key = (path, str(error.validator), schema_error_message(error))
+        if key in seen:
+            continue
+        seen.add(key)
+        result.append(error)
+    return result
+
+
+def schema_error_message(error: Any) -> str:
+    """Render a bounded, user-facing message for a JSON Schema error."""
+    if error.validator == "oneOf":
+        return "value is not valid under any of the given schemas"
+    if error.validator == "anyOf":
+        return "value is not valid under any of the given schemas"
+    return str(error.message)
+
+
 class AppFormContractError(ValueError):
     def __init__(self, error_code: str, message: str, *, path: str | None = None, details: JSONObject | None = None) -> None:
         super().__init__(message)
@@ -29,6 +139,7 @@ class AppFormSchemaContext:
     api_version: str
     complete_schema: JSONObject
     supported_types: tuple[str, ...]
+    supported_schema_kinds: tuple[str, ...]
     contract_source: str
     contract_version: str
     normalizer_version: str
@@ -39,11 +150,12 @@ class AppFormSchemaContext:
         errors = sorted(validator.iter_errors(payload), key=lambda item: (list(item.absolute_path), item.message))
         if not errors:
             return
-        error = errors[0]
+        compact_errors = compact_schema_errors(errors, self.complete_schema)
+        error = compact_errors[0] if compact_errors else errors[0]
         pointer = "".join(f"/{str(part).replace('~', '~0').replace('/', '~1')}" for part in error.absolute_path) or "/"
         raise AppFormContractError(
             "INVALID_SPEC",
-            error.message,
+            schema_error_message(error),
             path=pointer,
             details={"validator": error.validator, "schemaPath": "/".join(str(part) for part in error.absolute_schema_path)},
         )
@@ -131,6 +243,9 @@ class AppFormSchemaRegistry:
             api_version = str(metadata.get("apiVersion") or "")
             complete = self._read_json(root / version / "complete.json")
             supported = tuple(str(item) for item in metadata.get("fieldTypes") or ())
+            supported_schema_kinds = tuple(str(item) for item in metadata.get("schemaKinds") or ("summary", "field"))
+            if not {"summary", "field"}.issubset(supported_schema_kinds):
+                raise RuntimeError(f"AppForm schema version must support summary and field Schemas: {version}")
             if complete.get("properties", {}).get("apiVersion", {}).get("const") != api_version:
                 raise RuntimeError(f"AppForm schema apiVersion mismatch for {version}")
             schema_id = str(complete.get("$id") or "")
@@ -143,6 +258,11 @@ class AppFormSchemaRegistry:
                 raise RuntimeError(f"AppForm summary apiVersion mismatch for {version}")
             Draft202012Validator.check_schema(summary)
             self._validate_local_refs(summary, root / version / "summary.json")
+            if "formula" in supported_schema_kinds:
+                formula_path = root / version / "formula.json"
+                formula = self._read_json(formula_path)
+                Draft202012Validator.check_schema(formula)
+                self._validate_local_refs(formula, formula_path)
             for field_type in supported:
                 field_path = root / version / "fields" / f"{field_type}.json"
                 field_schema = self._read_json(field_path)
@@ -153,6 +273,7 @@ class AppFormSchemaRegistry:
                 api_version,
                 complete,
                 supported,
+                supported_schema_kinds,
                 str(metadata.get("contractSource") or "app_form"),
                 str(metadata.get("contractVersion") or version),
                 str(metadata.get("normalizerVersion") or version),
@@ -161,12 +282,46 @@ class AppFormSchemaRegistry:
             self._contexts[version] = context
             self._api_to_version[api_version] = version
 
-    def schema(self, *, schema_version: str | None = None, field_type: str | None = None) -> JSONObject:
+    def schema(
+        self,
+        *,
+        schema_version: str | None = None,
+        field_type: str | None = None,
+        schema_kind: str | None = None,
+    ) -> JSONObject:
         context = self.resolve_schema_version(schema_version)
-        if field_type is None:
+        requested_kind = str(schema_kind or ("field" if field_type is not None else "summary")).strip()
+        if requested_kind not in context.supported_schema_kinds:
+            raise AppFormContractError(
+                "UNSUPPORTED_SCHEMA_KIND",
+                f"unsupported AppForm schema kind: {requested_kind}",
+                details={"supportedKinds": list(context.supported_schema_kinds)},
+            )
+        if requested_kind == "formula":
+            if field_type is not None:
+                raise AppFormContractError(
+                    "INVALID_SCHEMA_SELECTION",
+                    "field_type cannot be combined with schema_kind=formula",
+                    details={"schemaKind": requested_kind, "fieldType": field_type},
+                )
+            schema = self._read_json(self.root / context.schema_version / "formula.json")
+            resolved_kind = "formula"
+        elif requested_kind == "summary":
+            if field_type is not None:
+                raise AppFormContractError(
+                    "INVALID_SCHEMA_SELECTION",
+                    "field_type requires schema_kind=field or an omitted schema_kind",
+                    details={"schemaKind": requested_kind, "fieldType": field_type},
+                )
             schema = self._read_json(self.root / context.schema_version / "summary.json")
-            schema_kind = "summary"
+            resolved_kind = "summary"
         else:
+            if field_type is None:
+                raise AppFormContractError(
+                    "INVALID_SCHEMA_SELECTION",
+                    "schema_kind=field requires field_type",
+                    details={"schemaKind": requested_kind, "supportedTypes": list(context.supported_types)},
+                )
             if field_type not in context.supported_types:
                 raise AppFormContractError(
                     "UNSUPPORTED_SCHEMA_FIELD_TYPE",
@@ -174,14 +329,15 @@ class AppFormSchemaRegistry:
                     details={"supportedTypes": list(context.supported_types)},
                 )
             schema = self._read_json(self.root / context.schema_version / "fields" / f"{field_type}.json")
-            schema_kind = "field"
+            resolved_kind = "field"
         return {
             "schemaVersion": context.schema_version,
             "apiVersion": context.api_version,
             "latestVersion": self.latest_version,
             "storedVersions": list(self.stored_versions),
             "enabledVersions": list(self.enabled_versions),
-            "schemaKind": schema_kind,
+            "supportedSchemaKinds": list(context.supported_schema_kinds),
+            "schemaKind": resolved_kind,
             "fieldType": field_type,
             "schema": schema,
         }

package/src/qingflow_mcp/builder_facade/schemas/app_form/manifest.json

@@ -31,6 +31,11 @@
         "subtable"
       ],
       "normalizerVersion": "v1alpha1",
+      "schemaKinds": [
+        "summary",
+        "field",
+        "formula"
+      ],
       "status": "active"
     }
   }