@josephyan/qingflow-cli 1.1.6 → 1.1.8

package/README.md

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@josephyan/qingflow-cli",
-  "version": "1.1.6",
+  "version": "1.1.8",
   "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.6"
+version = "1.1.8"
 description = "User-authenticated MCP server for Qingflow"
 readme = "README.md"
 license = "MIT"

package/src/qingflow_mcp/builder_facade/service.py

@@ -6524,6 +6524,7 @@ class AiBuilderFacade:
             )
         charts = _summarize_charts(items)
         chart_visibility_read_errors: list[dict[str, Any]] = []
+        chart_config_read_errors: list[dict[str, Any]] = []
         for chart in charts:
             chart_id = str(chart.get("chart_id") or "").strip()
             if not chart_id:
@@ -6546,6 +6547,24 @@ class AiBuilderFacade:
                     base_info.get("visibleAuth") if isinstance(base_info, dict) else None
                 )
             )
+            try:
+                config_response = self.charts.qingbi_report_get_config(profile=profile, chart_id=chart_id)
+                config = config_response.get("result") or {}
+            except (QingflowApiError, RuntimeError) as error:
+                api_error = _coerce_api_error(error)
+                chart_config_read_errors.append(
+                    {
+                        "chart_id": chart_id,
+                        "request_id": api_error.request_id,
+                        "http_status": api_error.http_status,
+                        "backend_code": api_error.backend_code,
+                    }
+                )
+                continue
+            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)
         response = AppChartsReadResponse(
             app_key=resolved_app_key,
             charts=charts,
@@ -6559,7 +6578,10 @@ class AiBuilderFacade:
             "normalized_args": {"app_key": resolved_app_key},
             "missing_fields": [],
             "allowed_values": {},
-            "details": {"chart_visibility_read_errors": chart_visibility_read_errors} if chart_visibility_read_errors else {},
+            "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 {}),
+            },
             "request_id": None,
             "suggested_next_call": None,
             "noop": False,
@@ -6570,14 +6592,20 @@ class AiBuilderFacade:
                     if chart_visibility_read_errors
                     else []
                 )
+                + (
+                    [_warning("CHART_CONFIG_READ_PARTIAL", "some chart configs could not be read back; metrics/group_by/filters are incomplete for those charts")]
+                    if chart_config_read_errors
+                    else []
+                )
             ),
             "verification": {
                 "app_exists": True,
                 "chart_order_verified": list_source == "sorted",
                 "chart_list_source": list_source,
                 "chart_visibility_readback_complete": not chart_visibility_read_errors,
+                "chart_config_readback_complete": not chart_config_read_errors,
             },
-            "verified": True,
+            "verified": not chart_config_read_errors,
             **response.model_dump(mode="json"),
         }
 
@@ -23264,6 +23292,15 @@ def _merge_view_summary_with_config(
             question_entries_by_id=query_question_entries_by_id,
         )
         config_enriched = True
+    if "viewgraphLimit" in config:
+        field_lookup = _view_field_lookup_from_question_entries(
+            [*question_entries, *canonical_question_entries]
+        )
+        summary["filters"] = _public_view_filter_groups_from_match_rules(
+            config.get("viewgraphLimit"),
+            current_fields_by_name=field_lookup,
+        )
+        config_enriched = True
     if any(key in config for key in ("asosChartVisible", "asosChartConfig", "asosChartIdList", "limitType")):
         summary["associated_resources_config"] = _extract_view_associated_resources_config(config)
         config_enriched = True
@@ -23321,6 +23358,24 @@ def _extract_view_question_entries(questions: Any) -> list[dict[str, Any]]:
                 "visible": visible,
                 "display_order": display_order if display_order is not None else fallback_order,
             }
+            option_details: list[dict[str, Any]] = []
+            option_values: list[str] = []
+            raw_options = item.get("options")
+            if isinstance(raw_options, list):
+                for raw_option in raw_options:
+                    if not isinstance(raw_option, dict):
+                        continue
+                    option_id = raw_option.get("optId")
+                    option_value = str(raw_option.get("optValue") or "").strip()
+                    if not option_value and option_id is None:
+                        continue
+                    if option_value:
+                        option_values.append(option_value)
+                    option_details.append({"id": option_id, "value": option_value or str(option_id)})
+            if option_values:
+                entry["options"] = option_values
+            if option_details:
+                entry["option_details"] = option_details
             width = _coerce_positive_int(item.get("width"))
             if width is not None:
                 entry["width"] = width
@@ -23330,6 +23385,43 @@ def _extract_view_question_entries(questions: Any) -> list[dict[str, Any]]:
     return entries
 
 
+def _view_field_lookup_from_question_entries(entries: list[dict[str, Any]]) -> dict[str, dict[str, Any]]:
+    fields_by_name: dict[str, dict[str, Any]] = {}
+    for entry in entries:
+        if not isinstance(entry, dict):
+            continue
+        name = str(entry.get("name") or entry.get("title") or "").strip()
+        que_id = _coerce_positive_int(entry.get("field_id") or entry.get("que_id") or entry.get("queId"))
+        if not name or que_id is None:
+            continue
+        field_entry: dict[str, Any] = {"name": name, "que_id": que_id}
+        options = entry.get("options")
+        if isinstance(options, list) and options:
+            field_entry["options"] = [str(value) for value in options if str(value or "").strip()]
+        option_details = entry.get("option_details")
+        if isinstance(option_details, list) and option_details:
+            field_entry["option_details"] = [deepcopy(value) for value in option_details if isinstance(value, dict)]
+        fields_by_name.setdefault(name, field_entry)
+    return fields_by_name
+
+
+def _view_field_lookup_from_summary(view: dict[str, Any]) -> dict[str, dict[str, Any]]:
+    entries = view.get("column_details")
+    if isinstance(entries, list):
+        return _view_field_lookup_from_question_entries([entry for entry in entries if isinstance(entry, dict)])
+    fields_by_name: dict[str, dict[str, Any]] = {}
+    names = view.get("columns")
+    ids = view.get("display_column_ids") or view.get("configured_column_ids") or []
+    if isinstance(names, list):
+        for index, raw_name in enumerate(names):
+            name = str(raw_name or "").strip()
+            if not name:
+                continue
+            que_id = _coerce_positive_int(ids[index] if isinstance(ids, list) and index < len(ids) else None)
+            fields_by_name.setdefault(name, {"name": name, "que_id": que_id})
+    return fields_by_name
+
+
 def _filter_public_view_display_entries(
     entries: list[dict[str, Any]],
     *,
@@ -24146,6 +24238,7 @@ def _custom_button_view_configs_from_view_summaries(views: list[dict[str, Any]])
         raw_buttons = view.get("buttons")
         if not isinstance(raw_buttons, list):
             continue
+        field_lookup = _view_field_lookup_from_summary(view)
         buttons: list[dict[str, Any]] = []
         for entry in raw_buttons:
             if not isinstance(entry, dict):
@@ -24153,6 +24246,12 @@ def _custom_button_view_configs_from_view_summaries(views: list[dict[str, Any]])
             if _normalize_view_button_type(entry.get("button_type")) != PublicViewButtonType.custom.value:
                 continue
             placement = _public_view_button_placement(entry.get("config_type")) or entry.get("placement")
+            raw_button_limit = deepcopy(entry.get("button_limit") or [])
+            public_button_limit = (
+                _public_view_filter_groups_from_match_rules(raw_button_limit, current_fields_by_name=field_lookup)
+                if raw_button_limit
+                else []
+            )
             button = _compact_dict(
                 {
                     "button_ref": _coerce_positive_int(entry.get("button_id")),
@@ -24160,7 +24259,7 @@ def _custom_button_view_configs_from_view_summaries(views: list[dict[str, Any]])
                     "button_text": entry.get("button_text"),
                     "placement": placement,
                     "primary": bool(entry.get("being_main", False)),
-                    "button_limit": deepcopy(entry.get("button_limit") or []),
+                    "button_limit": public_button_limit,
                     "button_formula": entry.get("button_formula"),
                     "button_formula_type": _coerce_positive_int(entry.get("button_formula_type")),
                     "print_tpls": deepcopy(entry.get("print_tpls") or []),
@@ -26418,6 +26517,38 @@ def _view_filter_rule_values_for_signature(rule: dict[str, Any]) -> list[str]:
     return fallback_values
 
 
+def _view_filter_option_value_by_id(field: dict[str, Any]) -> dict[str, str]:
+    value_by_id: dict[str, str] = {}
+    for detail in field.get("option_details") or []:
+        if not isinstance(detail, dict):
+            continue
+        option_id = detail.get("id")
+        option_value = str(detail.get("value") or "").strip()
+        if option_id is None or not option_value:
+            continue
+        value_by_id[str(option_id)] = option_value
+    return value_by_id
+
+
+def _public_view_filter_rule_values(rule: dict[str, Any], *, field: dict[str, Any]) -> list[str]:
+    value_by_id = _view_filter_option_value_by_id(field)
+    detail_value_by_id: dict[str, str] = {}
+    ordered_detail_values: list[str] = []
+    for detail in rule.get("judgeValueDetails") or []:
+        if not isinstance(detail, dict):
+            continue
+        detail_value = str(detail.get("value") or "").strip()
+        detail_id = detail.get("id")
+        if detail_value:
+            ordered_detail_values.append(detail_value)
+            if detail_id is not None:
+                detail_value_by_id[str(detail_id)] = detail_value
+    values = [str(value) for value in (rule.get("judgeValues") or []) if str(value or "").strip()]
+    if values:
+        return [value_by_id.get(value) or detail_value_by_id.get(value) or value for value in values]
+    return ordered_detail_values
+
+
 def _view_filter_groups_signature(groups: Any) -> list[list[dict[str, Any]]]:
     signature: list[list[dict[str, Any]]] = []
     for group in _normalize_view_filter_groups_for_compare(groups):
@@ -26499,7 +26630,7 @@ def _public_view_filter_groups_from_match_rules(
         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)
+            values = _public_view_filter_rule_values(rule, field=field)
             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")),