@josephyan/qingflow-cli 1.1.8 → 1.1.10

package/README.md

@@ -3,13 +3,13 @@
 Install:
 
 ```bash
-npm install @josephyan/qingflow-cli@1.1.8
+npm install @josephyan/qingflow-cli@1.1.10
 ```
 
 Run:
 
 ```bash
-npx -y -p @josephyan/qingflow-cli@1.1.8 qingflow
+npx -y -p @josephyan/qingflow-cli@1.1.10 qingflow
 ```
 
 Environment:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@josephyan/qingflow-cli",
-  "version": "1.1.8",
+  "version": "1.1.10",
   "description": "Human-friendly Qingflow command line interface for auth, record operations, import, tasks, and stable builder flows.",
   "license": "MIT",
   "type": "module",

package/pyproject.toml

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

package/src/qingflow_mcp/builder_facade/service.py

@@ -5999,6 +5999,20 @@ class AiBuilderFacade:
             result["message"] = "read app chart config"
         return result
 
+    def _chart_filter_field_names_by_id(
+        self,
+        *,
+        profile: str,
+        app_key: str,
+    ) -> tuple[dict[str, str], dict[str, Any] | None]:
+        try:
+            state = self._load_base_schema_state(profile=profile, app_key=app_key)
+        except (QingflowApiError, RuntimeError) as error:
+            api_error = _coerce_api_error(error)
+            return {}, _transport_error_payload(api_error)
+        fields = cast(list[dict[str, Any]], state["parsed"]["fields"])
+        return _chart_field_names_by_id_from_public_fields(app_key=app_key, fields=fields), None
+
     def app_get_buttons(self, *, profile: str, app_key: str) -> JSONObject:
         self.apps._require_app_key(app_key)
         warnings: list[dict[str, Any]] = []
@@ -6065,6 +6079,21 @@ class AiBuilderFacade:
                 details={"app_key": app_key},
                 suggested_next_call={"tool_name": "app_get", "arguments": {"profile": profile, "app_key": app_key}},
             )
+        match_mapping_errors = self._enrich_associated_resource_match_mappings(
+            profile=profile,
+            app_key=app_key,
+            resources=resources,
+        )
+        if match_mapping_errors:
+            verification["match_mappings_loaded"] = False
+            warnings.append(
+                _warning(
+                    "ASSOCIATED_RESOURCE_MATCH_MAPPINGS_PARTIAL",
+                    "associated resources were read, but some raw match rules could not be converted to semantic match_mappings",
+                )
+            )
+        else:
+            verification["match_mappings_loaded"] = True
         view_configs: list[dict[str, Any]] = []
         view_config_read_errors: list[dict[str, Any]] = []
         try:
@@ -6097,7 +6126,10 @@ class AiBuilderFacade:
             "view_config_count": len(view_configs),
             "warnings": warnings,
             "verification": verification,
-            "details": {"view_config_read_errors": view_config_read_errors} if view_config_read_errors else {},
+            "details": {
+                **({"view_config_read_errors": view_config_read_errors} if view_config_read_errors else {}),
+                **({"match_mapping_errors": match_mapping_errors} if match_mapping_errors else {}),
+            },
         }
 
     def flow_patch_nodes(
@@ -6525,6 +6557,7 @@ class AiBuilderFacade:
         charts = _summarize_charts(items)
         chart_visibility_read_errors: list[dict[str, Any]] = []
         chart_config_read_errors: list[dict[str, Any]] = []
+        field_name_by_id, field_name_read_error = self._chart_filter_field_names_by_id(profile=profile, app_key=resolved_app_key)
         for chart in charts:
             chart_id = str(chart.get("chart_id") or "").strip()
             if not chart_id:
@@ -6564,7 +6597,7 @@ class AiBuilderFacade:
             if isinstance(config, dict):
                 chart["group_by"] = _public_chart_group_by_from_qingbi_config(config)
                 chart["metrics"] = _public_chart_metrics_from_qingbi_config(config)
-                chart["filters"] = _public_chart_filter_groups_from_qingbi_config(config)
+                chart["filters"] = _public_chart_filter_groups_from_qingbi_config(config, field_name_by_id=field_name_by_id)
         response = AppChartsReadResponse(
             app_key=resolved_app_key,
             charts=charts,
@@ -6581,6 +6614,7 @@ class AiBuilderFacade:
             "details": {
                 **({"chart_visibility_read_errors": chart_visibility_read_errors} if chart_visibility_read_errors else {}),
                 **({"chart_config_read_errors": chart_config_read_errors} if chart_config_read_errors else {}),
+                **({"chart_filter_field_name_read_error": field_name_read_error} if field_name_read_error else {}),
             },
             "request_id": None,
             "suggested_next_call": None,
@@ -6597,6 +6631,11 @@ class AiBuilderFacade:
                     if chart_config_read_errors
                     else []
                 )
+                + (
+                    [_warning("CHART_FILTER_FIELD_NAMES_UNRESOLVED", "chart configs were read, but form fields could not be loaded to resolve filter field names")]
+                    if field_name_read_error
+                    else []
+                )
             ),
             "verification": {
                 "app_exists": True,
@@ -6604,8 +6643,9 @@ class AiBuilderFacade:
                 "chart_list_source": list_source,
                 "chart_visibility_readback_complete": not chart_visibility_read_errors,
                 "chart_config_readback_complete": not chart_config_read_errors,
+                "chart_filter_field_names_resolved": not field_name_read_error,
             },
-            "verified": not chart_config_read_errors,
+            "verified": not chart_config_read_errors and not field_name_read_error,
             **response.model_dump(mode="json"),
         }
 
@@ -6755,6 +6795,64 @@ class AiBuilderFacade:
 
         return self.apps._run(profile, runner)
 
+    def _match_field_index_for_app(self, *, profile: str, app_key: str) -> dict[int, dict[str, Any]]:
+        state = self._load_base_schema_state(profile=profile, app_key=app_key)
+        fields = cast(list[dict[str, Any]], state["parsed"]["fields"])
+        indexed: dict[int, dict[str, Any]] = {
+            -17: {"name": "数据ID", "que_id": -17, "type": "system"},
+            0: {"name": "编号", "que_id": 0, "type": "system"},
+        }
+        for field in fields:
+            que_id = _coerce_any_int(field.get("que_id"))
+            if que_id is not None:
+                indexed[que_id] = field
+        return indexed
+
+    def _enrich_associated_resource_match_mappings(
+        self,
+        *,
+        profile: str,
+        app_key: str,
+        resources: list[dict[str, Any]],
+    ) -> list[dict[str, Any]]:
+        if not any(isinstance(resource, dict) and resource.get("match_rules") for resource in resources):
+            return []
+        errors: list[dict[str, Any]] = []
+        source_fields: dict[int, dict[str, Any]] = {}
+        try:
+            source_fields = self._match_field_index_for_app(profile=profile, app_key=app_key)
+        except (QingflowApiError, RuntimeError) as error:
+            errors.append({"app_key": app_key, "resource": "source_fields", "transport_error": _transport_error_payload(_coerce_api_error(error))})
+        target_fields_by_app: dict[str, dict[int, dict[str, Any]]] = {}
+        for resource in resources:
+            if not isinstance(resource, dict):
+                continue
+            raw_rules = resource.get("match_rules")
+            if not raw_rules:
+                continue
+            target_app_key = str(resource.get("target_app_key") or app_key).strip()
+            if target_app_key not in target_fields_by_app:
+                try:
+                    target_fields_by_app[target_app_key] = self._match_field_index_for_app(profile=profile, app_key=target_app_key)
+                except (QingflowApiError, RuntimeError) as error:
+                    errors.append(
+                        {
+                            "associated_item_id": resource.get("associated_item_id"),
+                            "target_app_key": target_app_key,
+                            "resource": "target_fields",
+                            "transport_error": _transport_error_payload(_coerce_api_error(error)),
+                        }
+                    )
+                    target_fields_by_app[target_app_key] = {}
+            mappings = _public_associated_resource_match_mappings_from_rules(
+                raw_rules if isinstance(raw_rules, list) else [],
+                source_fields=source_fields,
+                target_fields=target_fields_by_app.get(target_app_key, {}),
+            )
+            if mappings:
+                resource["match_mappings"] = mappings
+        return errors
+
     def _associated_resource_create(
         self,
         *,
@@ -7803,11 +7901,24 @@ class AiBuilderFacade:
                     suggested_next_call={"tool_name": "chart_get", "arguments": {"profile": profile, "chart_id": chart_id}},
                 )
 
+        field_name_by_id: dict[str, str] = {}
+        data_source = config.get("dataSource") if isinstance(config.get("dataSource"), dict) else {}
+        data_source_app_key = str(data_source.get("dataSourceId") or config.get("dataSourceId") or "").strip()
+        if data_source_app_key:
+            field_name_by_id, field_name_error = self._chart_filter_field_names_by_id(profile=profile, app_key=data_source_app_key)
+            if field_name_error:
+                warnings.append(
+                    _warning(
+                        "CHART_FILTER_FIELD_NAMES_UNRESOLVED",
+                        "chart config was read, but form fields could not be loaded to resolve filter field names",
+                        **field_name_error,
+                    )
+                )
         response = ChartGetResponse(
             chart_id=chart_id,
             base=deepcopy(base) if isinstance(base, dict) else {},
             visibility=_public_visibility_from_chart_visible_auth(base.get("visibleAuth")),
-            filters=_public_chart_filter_groups_from_qingbi_config(config) if isinstance(config, dict) else [],
+            filters=_public_chart_filter_groups_from_qingbi_config(config, field_name_by_id=field_name_by_id) if isinstance(config, dict) else [],
             group_by=_public_chart_group_by_from_qingbi_config(config) if isinstance(config, dict) else [],
             metrics=_public_chart_metrics_from_qingbi_config(config) if isinstance(config, dict) else [],
             config=deepcopy(config) if isinstance(config, dict) else {},
@@ -16316,11 +16427,38 @@ def _qingbi_chart_filter_value_to_text(*, value: Any, form_field: dict[str, Any]
     reject(value)
 
 
-def _public_chart_filter_groups_from_qingbi_config(config: dict[str, Any]) -> list[list[dict[str, Any]]]:
+def _chart_field_names_by_id_from_public_fields(*, app_key: str, fields: list[dict[str, Any]]) -> dict[str, str]:
+    field_name_by_id: dict[str, str] = {}
+    for field in fields:
+        if not isinstance(field, dict):
+            continue
+        name = str(field.get("name") or "").strip()
+        if not name:
+            continue
+        que_id = field.get("que_id")
+        field_id = str(field.get("field_id") or "").strip()
+        for raw_key in (
+            que_id,
+            field_id,
+            f"{app_key}:{que_id}" if que_id is not None else None,
+            f"{app_key}:{field_id}" if field_id else None,
+        ):
+            key = str(raw_key or "").strip()
+            if key:
+                field_name_by_id.setdefault(key, name)
+    return field_name_by_id
+
+
+def _public_chart_filter_groups_from_qingbi_config(
+    config: dict[str, Any],
+    *,
+    field_name_by_id: dict[str, str] | None = None,
+) -> list[list[dict[str, Any]]]:
     groups: list[list[dict[str, Any]]] = []
     raw_groups = config.get("beforeAggregationFilterMatrix")
     if not isinstance(raw_groups, list):
         return groups
+    resolved_field_name_by_id = field_name_by_id or {}
     for raw_group in raw_groups:
         if not isinstance(raw_group, list):
             continue
@@ -16330,19 +16468,26 @@ def _public_chart_filter_groups_from_qingbi_config(config: dict[str, Any]) -> li
                 continue
             operator = _public_chart_filter_operator_from_judge_type(raw_rule.get("judgeType"))
             field_id = raw_rule.get("fieldId") or raw_rule.get("field_id")
-            field_name = (
+            field_id_text = _stringify_condition_value(field_id).strip() if field_id is not None else ""
+            raw_field_name = (
                 raw_rule.get("fieldName")
                 or raw_rule.get("field_name")
                 or raw_rule.get("queTitle")
                 or raw_rule.get("title")
-                or field_id
+            )
+            raw_field_name_text = _stringify_condition_value(raw_field_name).strip()
+            field_name = (
+                resolved_field_name_by_id.get(raw_field_name_text)
+                or resolved_field_name_by_id.get(field_id_text)
+                or raw_field_name_text
+                or field_id_text
             )
             public_rule: dict[str, Any] = {
-                "field_name": _stringify_condition_value(field_name).strip(),
+                "field_name": field_name,
                 "operator": operator,
             }
             if field_id is not None:
-                public_rule["field_id"] = _stringify_condition_value(field_id).strip()
+                public_rule["field_id"] = field_id_text
             values = _public_chart_filter_values_from_rule(raw_rule, operator=operator)
             if values:
                 public_rule["values"] = values
@@ -25070,12 +25215,83 @@ def _normalize_associated_resource_item(raw_item: Any, *, include_raw: bool = Fa
         if chart_type is not None:
             item["chart_type"] = _public_chart_type_from_backend(chart_type)
         item["report_source"] = _public_report_source_from_backend_source(source_type)
+    match_rules = _normalize_associated_resource_raw_match_rules(raw_item)
+    if match_rules:
+        item["match_rules"] = match_rules
     item = _compact_dict(item)
     if include_raw:
         item["_raw"] = deepcopy(raw_item)
     return item
 
 
+def _normalize_associated_resource_raw_match_rules(raw_item: dict[str, Any]) -> list[dict[str, Any]]:
+    raw_match_rules = _first_present(raw_item, "match_rules", "matchRules", "que_relation", "queRelation")
+    if not isinstance(raw_match_rules, list):
+        return []
+    flattened: list[dict[str, Any]] = []
+    if raw_match_rules and all(isinstance(group, list) for group in raw_match_rules):
+        for group in raw_match_rules:
+            flattened.extend(item for item in group if isinstance(item, dict))
+    else:
+        flattened.extend(item for item in raw_match_rules if isinstance(item, dict))
+    return [_normalize_custom_button_match_rule_for_public(rule) for rule in flattened]
+
+
+def _match_field_name(field_id: Any, *, fields_by_que_id: dict[int, dict[str, Any]], fallback: Any = None) -> str:
+    normalized_id = _coerce_any_int(field_id)
+    if normalized_id is not None:
+        field = fields_by_que_id.get(normalized_id) or {}
+        name = str(field.get("name") or field.get("title") or "").strip()
+        if name:
+            return name
+        if normalized_id == -17:
+            return "数据ID"
+        if normalized_id == 0:
+            return "编号"
+    fallback_text = str(fallback or "").strip()
+    return fallback_text or str(field_id or "").strip()
+
+
+def _public_associated_resource_match_mappings_from_rules(
+    rules: list[dict[str, Any]],
+    *,
+    source_fields: dict[int, dict[str, Any]],
+    target_fields: dict[int, dict[str, Any]],
+) -> list[dict[str, Any]]:
+    mappings: list[dict[str, Any]] = []
+    for rule in rules:
+        if not isinstance(rule, dict):
+            continue
+        target_field_id = _first_present(rule, "que_id", "queId")
+        target_field = target_fields.get(_coerce_any_int(target_field_id) or 0) or {}
+        target_name = _match_field_name(target_field_id, fields_by_que_id=target_fields, fallback=rule.get("que_title"))
+        operator = _public_view_filter_operator_from_judge_type(rule.get("judge_type"))
+        mapping: dict[str, Any] = {
+            "target_field": target_name,
+            "operator": operator,
+        }
+        if _coerce_any_int(rule.get("match_type")) == MATCH_TYPE_QUESTION:
+            source_field_id = _first_present(rule, "judge_que_id", "judgeQueId")
+            source_detail = rule.get("judge_que_detail") if isinstance(rule.get("judge_que_detail"), dict) else {}
+            mapping["source_field"] = _match_field_name(
+                source_field_id,
+                fields_by_que_id=source_fields,
+                fallback=source_detail.get("que_title"),
+            )
+        else:
+            value_rule = {
+                "judgeValues": rule.get("judge_values") or [],
+                "judgeValueDetails": rule.get("judge_value_details") or [],
+            }
+            values = _public_view_filter_rule_values(value_rule, field=target_field)
+            if len(values) == 1:
+                mapping["value"] = values[0]
+            elif values:
+                mapping["values"] = values
+        mappings.append(_compact_dict(mapping))
+    return mappings
+
+
 def _normalize_associated_graph_type(raw_item: dict[str, Any], *, chart_key: Any, view_key: Any) -> str:
     raw_graph_type = str(_first_present(raw_item, "graph_type", "graphType", "resourceType", "type") or "").strip().lower()
     raw_source_type = str(_first_present(raw_item, "source_type", "sourceType") or "").strip().lower()