@josephyan/qingflow-cli 1.1.8 → 1.1.9

package/README.md

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@josephyan/qingflow-cli",
-  "version": "1.1.8",
+  "version": "1.1.9",
   "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.9"
 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]] = []
@@ -6525,6 +6539,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 +6579,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 +6596,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 +6613,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 +6625,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"),
         }
 
@@ -7803,11 +7825,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 +16351,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 +16392,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