@josephyan/qingflow-cli 1.1.9 → 1.1.11

package/README.md

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

package/package.json

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

package/src/qingflow_mcp/builder_facade/service.py

@@ -6079,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:
@@ -6111,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(
@@ -6777,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,
         *,
@@ -25139,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()

package/src/qingflow_mcp/cli/commands/builder.py

@@ -898,7 +898,11 @@ def _handle_portal_apply(args: argparse.Namespace, context: CliContext) -> dict:
             fix_hint="Use `--dash-key` for an existing portal. For create mode, pass `--package-id --dash-name`.",
         )
     sections = [] if not args.sections_file else require_list_arg(args.sections_file, option_name="--sections-file")
-    patch_sections = load_list_arg(args.patch_sections_file, option_name="--patch-sections-file")
+    patch_sections = (
+        load_list_arg(args.patch_sections_file, option_name="--patch-sections-file")
+        if args.patch_sections_file
+        else None
+    )
     return context.builder.portal_apply(
         profile=args.profile,
         dash_key=args.dash_key,