@qingflow-tech/qingflow-app-builder-mcp 1.0.35 → 1.0.36

package/README.md

@@ -3,13 +3,13 @@
 Install:
 
 ```bash
-npm install @qingflow-tech/qingflow-app-builder-mcp@1.0.35
+npm install @qingflow-tech/qingflow-app-builder-mcp@1.0.36
 ```
 
 Run:
 
 ```bash
-npx -y -p @qingflow-tech/qingflow-app-builder-mcp@1.0.35 qingflow-app-builder-mcp
+npx -y -p @qingflow-tech/qingflow-app-builder-mcp@1.0.36 qingflow-app-builder-mcp
 ```
 
 Environment:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@qingflow-tech/qingflow-app-builder-mcp",
-  "version": "1.0.35",
+  "version": "1.0.36",
   "description": "Builder MCP for Qingflow app/package/system design and staged solution workflows.",
   "license": "MIT",
   "type": "module",

package/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "qingflow-mcp"
-version = "1.0.35"
+version = "1.0.36"
 description = "User-authenticated MCP server for Qingflow"
 readme = "README.md"
 license = "MIT"

package/src/qingflow_mcp/builder_facade/service.py

@@ -160,6 +160,7 @@ MATCH_TYPE_ACCURACY = 1
 MATCH_TYPE_QUESTION = 2
 JUDGE_EQUAL = 0
 JUDGE_UNEQUAL = 1
+JUDGE_INCLUDE = 2
 JUDGE_GREATER_OR_EQUAL = 5
 JUDGE_LESS_OR_EQUAL = 7
 JUDGE_EQUAL_ANY = 9
@@ -10125,14 +10126,31 @@ class AiBuilderFacade:
                             expected_filter_summary = _normalize_view_filter_groups_for_compare(expected_filters)
                             expected_data_scope = "CUSTOM" if expected_filter_summary else "ALL"
                             actual_data_scope = str(config_result.get("dataScope") or "").strip().upper() or None
-                            filters_verified = (
-                                _view_filter_groups_equivalent(expected_filter_summary, actual_filters)
-                                and actual_data_scope == expected_data_scope
+                            (
+                                filters_semantically_equivalent,
+                                semantic_actual_filters,
+                                lossy_filter_readbacks,
+                            ) = _view_filter_groups_semantic_readback(expected_filter_summary, actual_filters)
+                            filters_verified = filters_semantically_equivalent and actual_data_scope == expected_data_scope
+                            public_expected_filters = _public_view_filter_groups_from_match_rules(
+                                expected_filter_summary,
+                                current_fields_by_name=current_fields_by_name,
+                            )
+                            public_actual_filters = _public_view_filter_groups_from_match_rules(
+                                semantic_actual_filters,
+                                current_fields_by_name=current_fields_by_name,
                             )
                             verification_entry["filters_verified"] = filters_verified
                             verification_entry["view_key"] = verification_key
-                            verification_entry["expected_filters"] = expected_filter_summary
-                            verification_entry["actual_filters"] = actual_filters
+                            verification_entry["expected_filters"] = public_expected_filters
+                            verification_entry["actual_filters"] = public_actual_filters
+                            verification_entry["expected_filters_raw"] = expected_filter_summary
+                            if lossy_filter_readbacks:
+                                verification_entry["actual_filters_raw"] = actual_filters
+                                verification_entry["filter_value_readback_degraded"] = True
+                                verification_entry["filter_value_readback_warnings"] = lossy_filter_readbacks
+                            elif public_actual_filters != semantic_actual_filters:
+                                verification_entry["actual_filters_raw"] = semantic_actual_filters
                             verification_entry["expected_data_scope"] = expected_data_scope
                             verification_entry["actual_data_scope"] = actual_data_scope
                             if not filters_verified:
@@ -10140,8 +10158,10 @@ class AiBuilderFacade:
                                     {
                                         "name": name,
                                         "type": item.get("type"),
-                                        "expected_filters": expected_filter_summary,
-                                        "actual_filters": actual_filters,
+                                        "expected_filters": public_expected_filters,
+                                        "actual_filters": public_actual_filters,
+                                        "expected_filters_raw": expected_filter_summary,
+                                        "actual_filters_raw": actual_filters if lossy_filter_readbacks else semantic_actual_filters,
                                         "expected_data_scope": expected_data_scope,
                                         "actual_data_scope": actual_data_scope,
                                     }
@@ -22586,7 +22606,7 @@ def _translate_flow_condition_rule(*, field: dict[str, Any], rule: dict[str, Any
         base["judgeType"] = JUDGE_INCLUDE_ANY if field_type in INCLUDE_ANY_FLOW_FIELD_TYPES else JUDGE_EQUAL_ANY
         base["judgeValues"] = [_stringify_condition_value(value) for value in values]
     elif operator == "contains":
-        base["judgeType"] = JUDGE_FUZZY_MATCH
+        base["judgeType"] = JUDGE_INCLUDE
         base["judgeValues"] = [_stringify_condition_value(values[0])]
     elif operator == "gte":
         base["judgeType"] = JUDGE_GREATER_OR_EQUAL
@@ -24330,7 +24350,7 @@ def _translate_view_filter_rule(*, field: dict[str, Any], rule: dict[str, Any])
         payload["judgeType"] = JUDGE_INCLUDE_ANY if field_type in INCLUDE_ANY_FLOW_FIELD_TYPES else JUDGE_EQUAL_ANY
         payload["judgeValues"] = judge_values
     elif operator == "contains":
-        payload["judgeType"] = JUDGE_FUZZY_MATCH
+        payload["judgeType"] = JUDGE_INCLUDE
         payload["judgeValues"] = judge_values[:1] if judge_values else []
     elif operator == "gte":
         payload["judgeType"] = JUDGE_GREATER_OR_EQUAL
@@ -24515,6 +24535,96 @@ def _view_filter_groups_equivalent(expected: Any, actual: Any) -> bool:
     return _view_filter_groups_signature(expected) == _view_filter_groups_signature(actual)
 
 
+def _view_filter_groups_semantic_readback(expected: Any, actual: Any) -> tuple[bool, list[list[dict[str, Any]]], list[dict[str, Any]]]:
+    expected_groups = _normalize_view_filter_groups_for_compare(expected)
+    actual_groups = _normalize_view_filter_groups_for_compare(actual)
+    if _view_filter_groups_signature(expected_groups) == _view_filter_groups_signature(actual_groups):
+        return True, actual_groups, []
+    if len(expected_groups) != len(actual_groups):
+        return False, actual_groups, []
+    semantic_groups: list[list[dict[str, Any]]] = []
+    lossy_readbacks: list[dict[str, Any]] = []
+    for group_index, (expected_group, actual_group) in enumerate(zip(expected_groups, actual_groups)):
+        if len(expected_group) != len(actual_group):
+            return False, actual_groups, []
+        semantic_group: list[dict[str, Any]] = []
+        for rule_index, (expected_rule, actual_rule) in enumerate(zip(expected_group, actual_group)):
+            if expected_rule.get("queId") != actual_rule.get("queId") or expected_rule.get("judgeType") != actual_rule.get("judgeType"):
+                return False, actual_groups, []
+            expected_values = _view_filter_rule_values_for_signature(expected_rule)
+            actual_values = _view_filter_rule_values_for_signature(actual_rule)
+            if expected_values == actual_values:
+                semantic_group.append(actual_rule)
+                continue
+            if (
+                expected_values
+                and not actual_values
+                and actual_rule.get("judgeType") in {JUDGE_INCLUDE, JUDGE_FUZZY_MATCH}
+            ):
+                semantic_rule = deepcopy(actual_rule)
+                semantic_rule["judgeValues"] = expected_values
+                semantic_group.append(semantic_rule)
+                lossy_readbacks.append(
+                    {
+                        "group_index": group_index,
+                        "rule_index": rule_index,
+                        "queId": actual_rule.get("queId"),
+                        "judgeType": actual_rule.get("judgeType"),
+                        "message": "view filter literal value was accepted by write path but omitted by raw viewConfig readback; semantic readback was reconstructed from the write payload",
+                    }
+                )
+                continue
+            return False, actual_groups, []
+        semantic_groups.append(semantic_group)
+    return True, semantic_groups, lossy_readbacks
+
+
+def _public_view_filter_groups_from_match_rules(
+    groups: Any,
+    *,
+    current_fields_by_name: dict[str, dict[str, Any]],
+) -> list[list[dict[str, Any]]]:
+    fields_by_que_id = {
+        _coerce_positive_int(field.get("que_id")): field
+        for field in current_fields_by_name.values()
+        if isinstance(field, dict) and _coerce_positive_int(field.get("que_id")) is not None
+    }
+    public_groups: list[list[dict[str, Any]]] = []
+    for group in _normalize_view_filter_groups_for_compare(groups):
+        public_group: list[dict[str, Any]] = []
+        for rule in group:
+            que_id = _coerce_positive_int(rule.get("queId")) or 0
+            field = fields_by_que_id.get(que_id) or {}
+            values = _view_filter_rule_values_for_signature(rule)
+            public_rule: dict[str, Any] = {
+                "field_name": str(field.get("name") or rule.get("queTitle") or que_id),
+                "operator": _public_view_filter_operator_from_judge_type(rule.get("judgeType")),
+            }
+            if values:
+                public_rule["values"] = values
+            public_group.append(public_rule)
+        if public_group:
+            public_groups.append(public_group)
+    return public_groups
+
+
+def _public_view_filter_operator_from_judge_type(judge_type: Any) -> str:
+    normalized = _coerce_positive_int(judge_type)
+    if normalized == JUDGE_EQUAL:
+        return "eq"
+    if normalized == JUDGE_UNEQUAL:
+        return "neq"
+    if normalized in {JUDGE_INCLUDE, JUDGE_FUZZY_MATCH}:
+        return "contains"
+    if normalized in {JUDGE_EQUAL_ANY, JUDGE_INCLUDE_ANY}:
+        return "in"
+    if normalized == JUDGE_GREATER_OR_EQUAL:
+        return "gte"
+    if normalized == JUDGE_LESS_OR_EQUAL:
+        return "lte"
+    return f"judge_type:{judge_type}"
+
+
 def _infer_status_field_id(fields: list[dict[str, Any]]) -> str | None:
     preferred_names = {"status", "状态", "订单状态", "审批状态", "流程状态"}
     for field in fields: