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

package/README.md

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@qingflow-tech/qingflow-app-builder-mcp",
-  "version": "1.0.37",
+  "version": "1.0.39",
   "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.37"
+version = "1.0.39"
 description = "User-authenticated MCP server for Qingflow"
 readme = "README.md"
 license = "MIT"

package/src/qingflow_mcp/builder_facade/models.py

@@ -2215,6 +2215,7 @@ class ChartGetResponse(StrictModel):
     chart_id: str
     base: dict[str, Any] = Field(default_factory=dict)
     visibility: dict[str, Any] = Field(default_factory=dict)
+    filters: list[list[dict[str, Any]]] = Field(default_factory=list)
     config: dict[str, Any] = Field(default_factory=dict)
 
 

package/src/qingflow_mcp/builder_facade/service.py

@@ -7184,6 +7184,7 @@ class AiBuilderFacade:
             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 [],
             config=deepcopy(config) if isinstance(config, dict) else {},
         )
         return {
@@ -11378,11 +11379,14 @@ class AiBuilderFacade:
 
         if failed_items:
             successful_changes = bool(created_ids or updated_ids or removed_ids or reordered)
+            primary_failure = failed_items[0]
+            primary_error_code = str(primary_failure.get("error_code") or "").strip()
+            primary_message = str(primary_failure.get("message") or "").strip()
             return finalize({
                 "status": "partial_success" if successful_changes else "failed",
-                "error_code": "CHART_APPLY_PARTIAL" if successful_changes else "CHART_APPLY_FAILED",
+                "error_code": "CHART_APPLY_PARTIAL" if successful_changes else primary_error_code or "CHART_APPLY_FAILED",
                 "recoverable": True,
-                "message": "applied some chart operations; at least one chart operation failed" if successful_changes else "one or more chart operations failed",
+                "message": "applied some chart operations; at least one chart operation failed" if successful_changes else primary_message or "one or more chart operations failed",
                 "normalized_args": normalized_args,
                 "missing_fields": [],
                 "allowed_values": {"chart.chart_type": [member.value for member in PublicChartType], "chart.filter.operator": [member.value for member in ViewFilterOperator]},
@@ -11609,12 +11613,12 @@ class AiBuilderFacade:
                 base_payload=base_payload,
             )
             if sections_requested:
-                component_payload = self._build_portal_components_from_sections(
+                component_payload, layout_metadata = self._build_portal_components_from_sections(
                     profile=profile,
                     sections=request.sections,
                     layout_preset=request.layout_preset,
                 )
-                layout_diagnostics = _portal_layout_diagnostics(request.sections, component_payload)
+                layout_diagnostics = _portal_layout_diagnostics(request.sections, component_payload, layout_metadata=layout_metadata)
                 update_payload["components"] = component_payload
                 self.portals.portal_update(profile=profile, dash_key=dash_key, payload=update_payload)
                 write_executed = True
@@ -12560,8 +12564,9 @@ class AiBuilderFacade:
         profile: str,
         sections: list[PortalSectionPatch],
         layout_preset: str | None = None,
-    ) -> list[dict[str, Any]]:
+    ) -> tuple[list[dict[str, Any]], list[dict[str, Any]]]:
         resolved_components: list[dict[str, Any]] = []
+        layout_metadata: list[dict[str, Any]] = []
         pc_x = 0
         pc_y = 0
         pc_row_height = 0
@@ -12593,6 +12598,11 @@ class AiBuilderFacade:
                     profile=profile,
                     ref=section.chart_ref,
                 )
+                chart_type = str(
+                    resolved_chart.get("chart_type")
+                    or _public_chart_type_from_backend(section.config.get("chartType") or section.config.get("chart_type"))
+                    or ""
+                ).strip()
                 chart_config = {
                     "biChartId": resolved_chart["chart_id"],
                     "chartComponentTitle": section.title,
@@ -12600,6 +12610,7 @@ class AiBuilderFacade:
                     **deepcopy(section.config),
                 }
                 component = {"type": 9, "position": position_payload, "chartConfig": _compact_dict(chart_config)}
+                layout_metadata.append({"source_type": section.source_type, "chart_type": chart_type})
             elif section.source_type == "view":
                 resolved_view = _resolve_view_reference(
                     facade=self,
@@ -12622,26 +12633,31 @@ class AiBuilderFacade:
                     **deepcopy(section.config),
                 }
                 component = {"type": 10, "position": position_payload, "viewgraphConfig": _compact_dict(view_config)}
+                layout_metadata.append({"source_type": section.source_type})
             elif section.source_type == "grid":
                 component = {
                     "type": 2,
                     "position": position_payload,
                     "gridConfig": _compact_dict({"gridTitle": section.title, "beingShowTitle": True, **deepcopy(section.config)}),
                 }
+                layout_metadata.append({"source_type": section.source_type})
             elif section.source_type == "filter":
                 component = {"type": 6, "position": position_payload, "filterConfig": deepcopy(section.config)}
+                layout_metadata.append({"source_type": section.source_type})
             elif section.source_type == "text":
                 component = {"type": 5, "position": position_payload, "textConfig": {"text": section.text or "", **deepcopy(section.config)}}
+                layout_metadata.append({"source_type": section.source_type})
             else:
                 component = {
                     "type": 4,
                     "position": position_payload,
                     "linkConfig": {"url": section.url or "", "beingLoginAuth": False, **deepcopy(section.config)},
                 }
+                layout_metadata.append({"source_type": section.source_type})
             if dash_style is not None:
                 component["dashStyleConfigBO"] = dash_style
             resolved_components.append(component)
-        return resolved_components
+        return resolved_components, layout_metadata
 
     def _resolve_current_user_identity(self, *, profile: str) -> JSONObject:
         session_profile = self.apps.sessions.get_profile(profile)
@@ -15209,6 +15225,103 @@ 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]]]:
+    groups: list[list[dict[str, Any]]] = []
+    raw_groups = config.get("beforeAggregationFilterMatrix")
+    if not isinstance(raw_groups, list):
+        return groups
+    for raw_group in raw_groups:
+        if not isinstance(raw_group, list):
+            continue
+        group: list[dict[str, Any]] = []
+        for raw_rule in raw_group:
+            if not isinstance(raw_rule, dict):
+                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 = (
+                raw_rule.get("fieldName")
+                or raw_rule.get("field_name")
+                or raw_rule.get("queTitle")
+                or raw_rule.get("title")
+                or field_id
+            )
+            public_rule: dict[str, Any] = {
+                "field_name": _stringify_condition_value(field_name).strip(),
+                "operator": operator,
+            }
+            if field_id is not None:
+                public_rule["field_id"] = _stringify_condition_value(field_id).strip()
+            values = _public_chart_filter_values_from_rule(raw_rule, operator=operator)
+            if values:
+                public_rule["values"] = values
+            group.append(public_rule)
+        if group:
+            groups.append(group)
+    return groups
+
+
+def _public_chart_filter_operator_from_judge_type(judge_type: Any) -> str:
+    normalized = _stringify_condition_value(judge_type).strip()
+    mapping = {
+        "equal": "eq",
+        "equals": "eq",
+        "=": "eq",
+        "unequal": "neq",
+        "notEqual": "neq",
+        "!=": "neq",
+        "anyMatch": "in",
+        "oneOf": "in",
+        "include": "contains",
+        "contains": "contains",
+        "greaterOrEqual": "gte",
+        "gte": "gte",
+        "lessOrEqual": "lte",
+        "lte": "lte",
+        "isNull": "is_empty",
+        "empty": "is_empty",
+        "notNull": "not_empty",
+        "not_empty": "not_empty",
+    }
+    if normalized in mapping:
+        return mapping[normalized]
+    numeric = _coerce_nonnegative_int(judge_type)
+    if numeric is not None:
+        return _public_view_filter_operator_from_judge_type(numeric)
+    return f"judge_type:{judge_type}"
+
+
+def _public_chart_filter_values_from_rule(rule: dict[str, Any], *, operator: str) -> list[str]:
+    if operator in {"is_empty", "not_empty"}:
+        return []
+    raw_value = rule.get("judgeValue")
+    if raw_value is None and "judgeValues" in rule:
+        raw_value = rule.get("judgeValues")
+    values: list[str] = []
+    if isinstance(raw_value, list):
+        values = [_stringify_condition_value(value).strip() for value in raw_value]
+    elif isinstance(raw_value, str) and "<&&>" in raw_value:
+        values = [value.strip() for value in raw_value.split("<&&>")]
+    elif raw_value is not None:
+        values = [_stringify_condition_value(raw_value).strip()]
+    values = [value for value in values if value]
+    if values:
+        return values
+    for detail_key in ("judgeValueDetailList", "judgeValueDetails"):
+        details = rule.get(detail_key)
+        if not isinstance(details, list):
+            continue
+        for detail in details:
+            if not isinstance(detail, dict):
+                continue
+            for value_key in ("value", "label", "name", "title", "dataValue", "id"):
+                value = _stringify_condition_value(detail.get(value_key)).strip()
+                if value:
+                    values.append(value)
+                    break
+    return values
+
+
 def _build_public_chart_config_payload(
     *,
     patch: ChartUpsertPatch,
@@ -15418,6 +15531,17 @@ def _extract_chart_identifier(chart: Any) -> str:
     ).strip()
 
 
+def _chart_type_from_item(chart: Any) -> str:
+    if not isinstance(chart, dict):
+        return ""
+    return _public_chart_type_from_backend(
+        chart.get("chartType")
+        or chart.get("chart_type")
+        or chart.get("chartGraphType")
+        or chart.get("type")
+    )
+
+
 def _normalize_backend_chart_type(value: Any) -> str:
     raw = str(value or "").strip()
     if not raw:
@@ -15534,7 +15658,7 @@ def _portal_component_position_public(
         rows = 2
     elif source_name == "view":
         cols = 24
-        rows = 8
+        rows = 11
     elif source_name == "link":
         cols = 12
         rows = 2
@@ -15543,7 +15667,7 @@ def _portal_component_position_public(
             cols = 12
         else:
             cols = 8
-        rows = 6
+        rows = 7
     if cols == 24:
         if pc_x != 0:
             pc_y += pc_row_height
@@ -15578,7 +15702,12 @@ def _empty_portal_layout_diagnostics() -> dict[str, Any]:
     }
 
 
-def _portal_layout_diagnostics(sections: list[PortalSectionPatch], components: list[dict[str, Any]]) -> dict[str, Any]:
+def _portal_layout_diagnostics(
+    sections: list[PortalSectionPatch],
+    components: list[dict[str, Any]],
+    *,
+    layout_metadata: list[dict[str, Any]] | None = None,
+) -> dict[str, Any]:
     diagnostics = _empty_portal_layout_diagnostics()
     diagnostics["section_count"] = len(sections)
     explicit_count = sum(1 for section in sections if section.position is not None)
@@ -15593,16 +15722,26 @@ def _portal_layout_diagnostics(sections: list[PortalSectionPatch], components: l
         if pc:
             pc_positions.append(pc)
         section = sections[index] if index < len(sections) else None
+        metadata = layout_metadata[index] if isinstance(layout_metadata, list) and index < len(layout_metadata) and isinstance(layout_metadata[index], dict) else {}
         source_type = str(getattr(section, "source_type", "") or "").lower() if section is not None else ""
         title = str(getattr(section, "title", "") or "").strip() if section is not None else None
         cols = int(pc.get("cols") or 0)
         rows = int(pc.get("rows") or 0)
-        if source_type == "chart" and (cols < 8 or rows < 5):
+        chart_type = str(metadata.get("chart_type") or "").strip().lower()
+        is_metric_chart = chart_type in {"target", "indicator"}
+        min_chart_cols = 6 if is_metric_chart else 8
+        min_chart_rows = 5 if is_metric_chart else 7
+        if source_type == "chart" and (cols < min_chart_cols or rows < min_chart_rows):
             warnings.append(_warning(
                 "PORTAL_CHART_CARD_TOO_SMALL",
-                "chart portal card is too small; use at least pc.cols >= 8 and pc.rows >= 5, preferably rows >= 6",
+                (
+                    "metric chart portal card is too small; use at least pc.cols >= 6 and pc.rows >= 5"
+                    if is_metric_chart
+                    else "chart portal card is too small; use at least pc.cols >= 8 and pc.rows >= 7 for non-metric charts"
+                ),
                 section_index=index,
                 title=title,
+                chart_type=chart_type or None,
                 pc=deepcopy(pc),
             ))
         if section is not None and section.position is not None and not bool(getattr(section.position, "mobile_provided", False)):
@@ -15645,7 +15784,7 @@ def _resolve_chart_reference(*, charts: QingbiReportTools, profile: str, ref: An
             item_id = _extract_chart_identifier(item)
             item_name = str(item.get("chartName") or "").strip()
             if item_id == chart_id:
-                return {"chart_id": item_id, "chart_name": item_name, "app_key": app_key}
+                return {"chart_id": item_id, "chart_name": item_name, "app_key": app_key, "chart_type": _chart_type_from_item(item)}
         raise ValueError(f"chart ref chart_id '{chart_id}' could not be resolved under app '{app_key}'")
     matches = _find_charts_by_name(items, chart_name=chart_name)
     if len(matches) > 1:
@@ -15656,6 +15795,7 @@ def _resolve_chart_reference(*, charts: QingbiReportTools, profile: str, ref: An
             "chart_id": _extract_chart_identifier(item),
             "chart_name": str(item.get("chartName") or "").strip(),
             "app_key": app_key,
+            "chart_type": _chart_type_from_item(item),
         }
     raise ValueError(f"chart ref could not be resolved under app '{app_key}'")
 
@@ -24716,7 +24856,7 @@ def _public_view_filter_groups_from_match_rules(
 
 
 def _public_view_filter_operator_from_judge_type(judge_type: Any) -> str:
-    normalized = _coerce_positive_int(judge_type)
+    normalized = _coerce_nonnegative_int(judge_type)
     if normalized == JUDGE_EQUAL:
         return "eq"
     if normalized == JUDGE_UNEQUAL: