@josephyan/qingflow-app-user-mcp 0.2.0-beta.88 → 0.2.0-beta.89

package/README.md

@@ -3,13 +3,13 @@
 Install:
 
 ```bash
-npm install @josephyan/qingflow-app-user-mcp@0.2.0-beta.88
+npm install @josephyan/qingflow-app-user-mcp@0.2.0-beta.89
 ```
 
 Run:
 
 ```bash
-npx -y -p @josephyan/qingflow-app-user-mcp@0.2.0-beta.88 qingflow-app-user-mcp
+npx -y -p @josephyan/qingflow-app-user-mcp@0.2.0-beta.89 qingflow-app-user-mcp
 ```
 
 Environment:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@josephyan/qingflow-app-user-mcp",
-  "version": "0.2.0-beta.88",
+  "version": "0.2.0-beta.89",
   "description": "Operational end-user MCP for Qingflow records, tasks, comments, and directory workflows.",
   "license": "MIT",
   "type": "module",

package/src/qingflow_mcp/builder_facade/service.py

@@ -4789,12 +4789,22 @@ class AiBuilderFacade:
             response = _apply_permission_outcomes(response, relation_permission_outcome)
             return finalize(self._append_publish_result(profile=profile, app_key=target.app_key, publish=publish, response=response))
 
-        payload = _build_form_payload_from_fields(
-            title=effective_app_name,
-            current_schema=schema_result,
-            fields=current_fields,
-            layout=layout,
-            question_relations=compiled_question_relations,
+        payload = (
+            _build_form_payload_from_fields(
+                title=effective_app_name,
+                current_schema=schema_result,
+                fields=current_fields,
+                layout=layout,
+                question_relations=compiled_question_relations,
+            )
+            if bool(resolved.get("created"))
+            else _build_form_payload_for_edit_fields(
+                title=effective_app_name,
+                current_schema=schema_result,
+                fields=current_fields,
+                layout=layout,
+                question_relations=compiled_question_relations,
+            )
         )
         payload["editVersionNo"] = self._resolve_form_edit_version(
             profile=profile,
@@ -4897,12 +4907,22 @@ class AiBuilderFacade:
                     },
                     suggested_next_call={"tool_name": "app_get_fields", "arguments": {"profile": profile, "app_key": target.app_key}},
                 )
-            rebound_payload = _build_form_payload_from_fields(
-                title=effective_app_name,
-                current_schema=rebound_schema,
-                fields=rebound_fields,
-                layout=rebound_layout,
-                question_relations=compiled_question_relations,
+            rebound_payload = (
+                _build_form_payload_from_fields(
+                    title=effective_app_name,
+                    current_schema=rebound_schema,
+                    fields=rebound_fields,
+                    layout=rebound_layout,
+                    question_relations=compiled_question_relations,
+                )
+                if bool(resolved.get("created"))
+                else _build_form_payload_for_edit_fields(
+                    title=effective_app_name,
+                    current_schema=rebound_schema,
+                    fields=rebound_fields,
+                    layout=rebound_layout,
+                    question_relations=compiled_question_relations,
+                )
             )
             rebound_payload["editVersionNo"] = self._resolve_form_edit_version(
                 profile=profile,
@@ -9844,8 +9864,8 @@ def _parse_field(question: dict[str, Any], *, field_id_hint: str | None = None)
         "subfields": [],
         "que_id": que_id,
         "que_type": que_type,
-        "default_type": _coerce_positive_int(question.get("queDefaultType")) or 1,
-        "default_value": question.get("queDefaultValue"),
+        "default_type": _coerce_positive_int(question.get("queDefaultType")) if "queDefaultType" in question else None,
+        "default_value": question.get("queDefaultValue") if "queDefaultValue" in question else None,
     }
     if field_type in {FieldType.single_select.value, FieldType.multi_select.value, FieldType.boolean.value}:
         options = question.get("options")
@@ -9893,7 +9913,6 @@ def _parse_field(question: dict[str, Any], *, field_id_hint: str | None = None)
         field["visible_fields"] = visible_fields
         field["field_name_show"] = bool(reference.get("fieldNameShow", True))
         field["_reference_config_template"] = deepcopy(reference)
-        field["_question_template"] = deepcopy(question)
         field["_relation_config_explicit"] = False
     if field_type == FieldType.department:
         department_scope = _normalize_department_scope_from_question(question)
@@ -9961,6 +9980,7 @@ def _parse_field(question: dict[str, Any], *, field_id_hint: str | None = None)
                 continue
             subfields.append(_parse_field(sub_question))
         field["subfields"] = subfields
+    field["_question_template"] = deepcopy(question)
     return field
 
 
@@ -10847,53 +10867,82 @@ def _apply_field_mutation(field: dict[str, Any], mutation: Any) -> None:
         payload.get("type") == FieldType.relation.value
         or any(key in payload for key in ("target_app_key", "display_field", "visible_fields", "relation_mode"))
     )
+    question_overlay_keys = set(cast(list[str], field.get("_question_overlay_keys") or []))
+    question_rebuild_required = bool(field.get("_question_rebuild_required"))
     if "name" in payload:
         field["name"] = payload["name"]
+        question_overlay_keys.add("name")
     if "type" in payload:
         field["type"] = payload["type"]
+        question_rebuild_required = True
     if "required" in payload:
         field["required"] = payload["required"]
+        question_overlay_keys.add("required")
     if "description" in payload:
         field["description"] = payload["description"]
+        question_overlay_keys.add("description")
     if "options" in payload:
         field["options"] = list(payload["options"])
+        question_rebuild_required = True
     if "target_app_key" in payload:
         field["target_app_key"] = payload["target_app_key"]
+        question_rebuild_required = True
     if "display_field" in payload:
         field["display_field"] = payload["display_field"]
+        question_rebuild_required = True
     if "visible_fields" in payload:
         field["visible_fields"] = list(payload["visible_fields"])
+        question_rebuild_required = True
     if "relation_mode" in payload:
         field["relation_mode"] = payload["relation_mode"]
+        question_rebuild_required = True
     if "department_scope" in payload:
         field["department_scope"] = payload["department_scope"]
+        question_rebuild_required = True
     if "remote_lookup_config" in payload:
         field["remote_lookup_config"] = payload["remote_lookup_config"]
         field["config"] = deepcopy(payload["remote_lookup_config"])
         field["_explicit_remote_lookup_config"] = True
+        question_rebuild_required = True
     if "q_linker_binding" in payload:
         field["q_linker_binding"] = payload["q_linker_binding"]
         if "remote_lookup_config" not in payload:
             field["_explicit_remote_lookup_config"] = False
+        question_rebuild_required = True
     if "code_block_config" in payload:
         field["code_block_config"] = payload["code_block_config"]
         field["config"] = deepcopy(payload["code_block_config"])
+        question_rebuild_required = True
     if "code_block_binding" in payload:
         field["code_block_binding"] = payload["code_block_binding"]
         field["_explicit_code_block_binding"] = True
+        question_rebuild_required = True
     if "auto_trigger" in payload:
         field["auto_trigger"] = payload["auto_trigger"]
+        question_rebuild_required = True
     if "custom_button_text_enabled" in payload:
         field["custom_button_text_enabled"] = payload["custom_button_text_enabled"]
+        question_rebuild_required = True
     if "custom_button_text" in payload:
         field["custom_button_text"] = payload["custom_button_text"]
+        question_rebuild_required = True
     if "subfields" in payload:
         field["subfields"] = [_field_patch_to_internal(item) for item in payload["subfields"]]
+        question_rebuild_required = True
     if relation_config_explicit:
         field["_relation_config_explicit"] = True
+        question_rebuild_required = True
     elif payload.get("type") and payload.get("type") != FieldType.relation.value:
         field.pop("_relation_config_explicit", None)
         field.pop("_reference_config_template", None)
+    if question_overlay_keys:
+        field["_question_overlay_keys"] = sorted(question_overlay_keys)
+    else:
+        field.pop("_question_overlay_keys", None)
+    if question_rebuild_required:
+        field["_question_rebuild_required"] = True
+    else:
+        field.pop("_question_rebuild_required", None)
 
 
 def _resolve_field_selector_with_uniqueness(
@@ -12691,6 +12740,42 @@ def _verify_package_attachment(packages: PackageTools, *, profile: str, tag_id:
     return last_result
 
 
+def _field_question_overlay_keys(field: dict[str, Any]) -> set[str]:
+    raw_value = field.get("_question_overlay_keys")
+    if isinstance(raw_value, set):
+        return {str(item) for item in raw_value if isinstance(item, str) and item}
+    if isinstance(raw_value, list):
+        return {str(item) for item in raw_value if isinstance(item, str) and item}
+    return set()
+
+
+def _field_needs_question_rebuild(field: dict[str, Any]) -> bool:
+    return not isinstance(field.get("_question_template"), dict) or bool(field.get("_question_rebuild_required"))
+
+
+def _materialize_preserved_question(field: dict[str, Any]) -> dict[str, Any] | None:
+    template = deepcopy(field.get("_question_template"))
+    if not isinstance(template, dict):
+        return None
+    overlay_keys = _field_question_overlay_keys(field)
+    if "name" in overlay_keys:
+        template["queTitle"] = str(field.get("name") or "")
+    if "required" in overlay_keys:
+        template["required"] = bool(field.get("required", False))
+    if "description" in overlay_keys:
+        description = field.get("description")
+        template["queHint"] = "" if description is None else str(description)
+    return template
+
+
+def _materialize_edit_question(field: dict[str, Any], *, temp_id: int) -> tuple[dict[str, Any], bool]:
+    if not _field_needs_question_rebuild(field):
+        preserved = _materialize_preserved_question(field)
+        if preserved is not None:
+            return preserved, True
+    return _field_to_question(field, temp_id=temp_id), False
+
+
 def _field_to_question(field: dict[str, Any], *, temp_id: int) -> dict[str, Any]:
     built_question, _next_temp_id = build_question(
         {
@@ -12746,7 +12831,6 @@ def _field_to_question(field: dict[str, Any], *, temp_id: int) -> dict[str, Any]
         )
         if preserved_reference is not None:
             preserved_reference["referAppKey"] = field.get("target_app_key")
-            preserved_reference["_targetEntityId"] = field.get("target_app_key")
             question["referenceConfig"] = preserved_reference
         else:
             reference = deepcopy(question.get("referenceConfig")) if isinstance(question.get("referenceConfig"), dict) else {}
@@ -12914,6 +12998,96 @@ def _build_form_payload_from_fields(
     return payload
 
 
+def _build_form_payload_for_edit_fields(
+    *,
+    title: str,
+    current_schema: dict[str, Any],
+    fields: list[dict[str, Any]],
+    layout: dict[str, Any],
+    question_relations: list[dict[str, Any]] | None = None,
+) -> dict[str, Any]:
+    _, section_templates = _extract_question_templates(current_schema)
+    fields_by_name = {
+        str(field.get("name") or ""): field
+        for field in fields
+        if isinstance(field, dict) and str(field.get("name") or "").strip()
+    }
+    form_rows: list[list[dict[str, Any]]] = []
+    temp_id = -10000
+
+    for row in layout.get("root_rows", []) or []:
+        questions: list[dict[str, Any]] = []
+        row_preserved = True
+        for name in row:
+            field = fields_by_name.get(str(name))
+            if field is None:
+                continue
+            question, preserved = _materialize_edit_question(field, temp_id=temp_id)
+            questions.append(question)
+            row_preserved = row_preserved and preserved
+            temp_id -= 100
+        if not questions:
+            continue
+        if not row_preserved:
+            _apply_row_widths(questions)
+        form_rows.append(questions)
+
+    for section in layout.get("sections", []) or []:
+        inner_rows: list[list[dict[str, Any]]] = []
+        for row in section.get("rows", []) or []:
+            questions: list[dict[str, Any]] = []
+            row_preserved = True
+            for name in row:
+                field = fields_by_name.get(str(name))
+                if field is None:
+                    continue
+                question, preserved = _materialize_edit_question(field, temp_id=temp_id)
+                questions.append(question)
+                row_preserved = row_preserved and preserved
+                temp_id -= 100
+            if not questions:
+                continue
+            if not row_preserved:
+                _apply_row_widths(questions)
+            inner_rows.append(questions)
+        if not inner_rows:
+            continue
+        template = _select_section_template(section_templates, section)
+        wrapper = deepcopy(template) if isinstance(template, dict) else {
+            "queId": 0,
+            "queTempId": -(20000 + sum(ord(ch) for ch in str(section.get("section_id") or section.get("title") or "section"))),
+            "queType": 24,
+            "queWidth": 100,
+            "scanType": 1,
+            "status": 1,
+            "required": False,
+            "queHint": "",
+            "linkedQuestions": {},
+            "logicalShow": True,
+            "queDefaultValue": None,
+            "queDefaultType": 1,
+            "subQueWidth": 2,
+            "beingHide": False,
+            "beingDesensitized": False,
+        }
+        if section.get("title") is not None:
+            wrapper["queTitle"] = section.get("title") or wrapper.get("queTitle") or "未命名分组"
+        parsed_section_id = _coerce_positive_int(section.get("section_id"))
+        if parsed_section_id is not None:
+            wrapper["sectionId"] = parsed_section_id
+        elif template is None and section.get("section_id") is not None:
+            wrapper["sectionId"] = section.get("section_id")
+        wrapper["innerQuestions"] = inner_rows
+        form_rows.append([wrapper])
+
+    payload = deepcopy(current_schema)
+    payload["formTitle"] = title
+    payload["formQues"] = form_rows
+    payload["questionRelations"] = deepcopy(question_relations if question_relations is not None else (current_schema.get("questionRelations") or []))
+    payload["editVersionNo"] = int(current_schema.get("editVersionNo") or 1)
+    return payload
+
+
 def _apply_row_widths(row: list[dict[str, Any]]) -> None:
     if not row:
         return