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

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.37
 ```
 
 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.37 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.37",
   "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.37"
 description = "User-authenticated MCP server for Qingflow"
 readme = "README.md"
 license = "MIT"

package/src/qingflow_mcp/builder_facade/service.py

@@ -9,7 +9,7 @@ import random
 import re
 import string
 import tempfile
-from typing import Any, cast
+from typing import Any, NoReturn, cast
 from urllib.parse import quote_plus, unquote_plus
 from uuid import uuid4
 
@@ -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,
                                     }
@@ -14595,7 +14615,18 @@ def _build_qingbi_chart_field_lookup(
     field_lookup: dict[str, dict[str, Any]],
 ) -> dict[str, Any]:
     by_selector: dict[str, list[dict[str, Any]]] = {}
-    form_by_que_id = field_lookup.get("by_que_id") or {}
+    form_by_que_id = dict(field_lookup.get("by_que_id") or {})
+    if not form_by_que_id:
+        for bucket_name in ("by_name", "by_field_id"):
+            bucket = field_lookup.get(bucket_name) or {}
+            if not isinstance(bucket, dict):
+                continue
+            for form_field in bucket.values():
+                if not isinstance(form_field, dict):
+                    continue
+                que_id = _coerce_any_int(form_field.get("que_id"))
+                if que_id is not None:
+                    form_by_que_id.setdefault(que_id, form_field)
 
     def add_selector(key: Any, field: dict[str, Any]) -> None:
         normalized = str(key or "").strip()
@@ -15075,13 +15106,109 @@ def _build_public_chart_filter_matrix(
                 "fieldName": qingbi_field.get("fieldName") or form_field.get("name") or field_id,
                 "fieldType": qingbi_field.get("fieldType") or _qingbi_field_type_from_public_field(str(form_field.get("type") or "")),
                 "judgeType": judge_map.get(operator, "equal"),
-                "judgeValues": values,
+                "judgeValue": _build_qingbi_chart_filter_judge_value(
+                    operator=operator,
+                    values=values,
+                    form_field=form_field,
+                    chart_type=chart_type,
+                ),
+                "judgeValueDetailList": [],
                 "matchType": 1,
             }
         )
     return [group] if group else []
 
 
+def _build_qingbi_chart_filter_judge_value(
+    *,
+    operator: str,
+    values: list[Any],
+    form_field: dict[str, Any],
+    chart_type: str,
+) -> str | None:
+    if operator in {ViewFilterOperator.is_empty.value, ViewFilterOperator.not_empty.value}:
+        return None
+    if operator == ViewFilterOperator.in_.value:
+        return "<&&>".join(
+            _qingbi_chart_filter_value_to_text(value=value, form_field=form_field, chart_type=chart_type) for value in values
+        )
+    if not values:
+        return ""
+    return _qingbi_chart_filter_value_to_text(value=values[0], form_field=form_field, chart_type=chart_type)
+
+
+def _qingbi_chart_filter_value_to_text(*, value: Any, form_field: dict[str, Any], chart_type: str) -> str:
+    option_details = [
+        item
+        for item in (form_field.get("option_details") or [])
+        if isinstance(item, dict) and item.get("id") is not None and item.get("value") is not None
+    ]
+    if not option_details:
+        if isinstance(value, dict):
+            for key in ("value", "label", "name", "title"):
+                raw = str(value.get(key) or "").strip()
+                if raw:
+                    return raw
+            if value.get("id") is not None:
+                return str(value.get("id"))
+        return _stringify_condition_value(value)
+
+    option_by_value = {str(item.get("value") or "").strip(): item for item in option_details if str(item.get("value") or "").strip()}
+    option_by_id = {str(item.get("id")): item for item in option_details if item.get("id") is not None}
+
+    def resolve(raw: Any) -> str | None:
+        text = _stringify_condition_value(raw).strip()
+        if not text:
+            return None
+        matched = option_by_value.get(text) or option_by_id.get(text)
+        if not matched:
+            return None
+        return str(matched.get("value") or "").strip()
+
+    def reject(raw: Any) -> NoReturn:
+        allowed = [
+            {"id": str(item.get("id")), "value": str(item.get("value"))}
+            for item in option_details
+        ]
+        _raise_chart_rule(
+            rule_code="CHART_FILTER_OPTION_VALUE_UNSUPPORTED",
+            chart_type=chart_type,
+            message="chart filter value is not in the field option list",
+            expected="Use an existing option label or option id from the target field schema.",
+            actual={
+                "field_name": form_field.get("name"),
+                "field_id": form_field.get("que_id"),
+                "value": raw,
+                "allowed_values": allowed,
+            },
+            offending_fields=[{"field_name": form_field.get("name"), "field_id": form_field.get("que_id"), "options": allowed}],
+            next_action="Read schema first, then pass one of the allowed option labels or option ids.",
+        )
+
+    if isinstance(value, dict):
+        for key in ("value", "label", "name", "title"):
+            if value.get(key) is not None:
+                resolved = resolve(value.get(key))
+                if resolved is not None:
+                    return resolved
+                reject(value.get(key))
+        if value.get("id") is not None:
+            resolved = resolve(value.get("id"))
+            if resolved is not None:
+                return resolved
+            reject(value.get("id"))
+        reject(value)
+    if isinstance(value, int):
+        resolved = resolve(value)
+        if resolved is not None:
+            return resolved
+        reject(value)
+    resolved = resolve(value)
+    if resolved is not None:
+        return resolved
+    reject(value)
+
+
 def _build_public_chart_config_payload(
     *,
     patch: ChartUpsertPatch,
@@ -22586,7 +22713,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 +24457,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 +24642,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: