@josephyan/qingflow-app-user-mcp 0.2.0-beta.91 → 0.2.0-beta.92

package/README.md

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

package/package.json

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

package/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "qingflow-mcp"
-version = "0.2.0b91"
+version = "0.2.0b92"
 description = "User-authenticated MCP server for Qingflow"
 readme = "README.md"
 license = "MIT"

package/src/qingflow_mcp/__init__.py

@@ -1,5 +1,37 @@
 from __future__ import annotations
 
+from importlib.metadata import PackageNotFoundError, packages_distributions, version as _dist_version
+from pathlib import Path
+
 __all__ = ["__version__"]
 
-__version__ = "0.2.0b87"
+_FALLBACK_VERSION = "0.2.0b92"
+
+
+def _resolve_local_pyproject_version() -> str | None:
+    module_path = Path(__file__).resolve()
+    for parent in module_path.parents:
+        candidate = parent / "pyproject.toml"
+        if not candidate.is_file():
+            continue
+        for line in candidate.read_text(encoding="utf-8").splitlines():
+            stripped = line.strip()
+            if stripped.startswith("version = "):
+                return stripped.split("=", 1)[1].strip().strip('"')
+        break
+    return None
+
+
+def _resolve_runtime_version() -> str:
+    local_version = _resolve_local_pyproject_version()
+    if local_version:
+        return local_version
+    for dist_name in packages_distributions().get("qingflow_mcp", []):
+        try:
+            return _dist_version(dist_name)
+        except PackageNotFoundError:
+            continue
+    return _FALLBACK_VERSION
+
+
+__version__ = _resolve_runtime_version()

package/src/qingflow_mcp/builder_facade/service.py

@@ -9865,8 +9865,9 @@ def _parse_field(question: dict[str, Any], *, field_id_hint: str | None = None)
         "que_id": que_id,
         "que_type": que_type,
         "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 "queDefaultValue" in question:
+        field["default_value"] = question.get("queDefaultValue")
     if field_type in {FieldType.single_select.value, FieldType.multi_select.value, FieldType.boolean.value}:
         options = question.get("options")
         if isinstance(options, list):
@@ -12753,6 +12754,65 @@ 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 _extract_template_row_lengths(schema: dict[str, Any]) -> tuple[dict[int, int], dict[str, int]]:
+    lengths_by_que_id: dict[int, int] = {}
+    lengths_by_title: dict[str, int] = {}
+
+    def remember_row(row: Any) -> None:
+        if not isinstance(row, list):
+            return
+        questions = [question for question in row if isinstance(question, dict)]
+        row_length = len(questions)
+        if row_length <= 0:
+            return
+        for question in questions:
+            que_id = _coerce_nonnegative_int(question.get("queId"))
+            if que_id is not None:
+                lengths_by_que_id[que_id] = row_length
+            title = str(question.get("queTitle") or "").strip()
+            if title:
+                lengths_by_title[title] = row_length
+
+    for row in schema.get("formQues", []) or []:
+        if not isinstance(row, list):
+            continue
+        if len(row) == 1 and isinstance(row[0], dict) and _coerce_positive_int(row[0].get("queType")) == 24:
+            for inner_row in row[0].get("innerQuestions", []) or []:
+                remember_row(inner_row)
+            continue
+        remember_row(row)
+    return lengths_by_que_id, lengths_by_title
+
+
+def _field_template_row_length(
+    field: dict[str, Any],
+    *,
+    lengths_by_que_id: dict[int, int],
+    lengths_by_title: dict[str, int],
+) -> int | None:
+    que_id = _coerce_nonnegative_int(field.get("que_id"))
+    if que_id is not None and que_id in lengths_by_que_id:
+        return lengths_by_que_id[que_id]
+    template = field.get("_question_template")
+    if isinstance(template, dict):
+        template_que_id = _coerce_nonnegative_int(template.get("queId"))
+        if template_que_id is not None and template_que_id in lengths_by_que_id:
+            return lengths_by_que_id[template_que_id]
+        template_title = str(template.get("queTitle") or "").strip()
+        if template_title and template_title in lengths_by_title:
+            return lengths_by_title[template_title]
+    field_name = str(field.get("name") or "").strip()
+    if field_name and field_name in lengths_by_title:
+        return lengths_by_title[field_name]
+    return None
+
+
+def _row_needs_width_reflow(expected_template_lengths: list[int], current_row_length: int) -> bool:
+    if current_row_length <= 0:
+        return False
+    return any(length != current_row_length for length in expected_template_lengths)
+
+
 def _materialize_preserved_question(field: dict[str, Any]) -> dict[str, Any] | None:
     template = deepcopy(field.get("_question_template"))
     if not isinstance(template, dict):
@@ -12802,12 +12862,21 @@ def _field_to_question(field: dict[str, Any], *, temp_id: int) -> dict[str, Any]
         },
         temp_id,
     )
+    relation_config_explicit = bool(field.get("_relation_config_explicit"))
     relation_question_template = (
         deepcopy(field.get("_question_template"))
         if field.get("type") == FieldType.relation.value and isinstance(field.get("_question_template"), dict)
         else None
     )
-    question = relation_question_template if relation_question_template is not None else built_question
+    question = (
+        relation_question_template
+        if relation_question_template is not None and not relation_config_explicit
+        else built_question
+    )
+    if relation_config_explicit and relation_question_template is not None:
+        for key in ("queOriginType", "relationDisplayMode", "customRenderConfig"):
+            if key in relation_question_template:
+                question[key] = deepcopy(relation_question_template[key])
     if _coerce_nonnegative_int(field.get("que_id")) is not None:
         question["queId"] = field["que_id"]
         question.pop("queTempId", None)
@@ -12826,19 +12895,28 @@ def _field_to_question(field: dict[str, Any], *, temp_id: int) -> dict[str, Any]
     if field.get("type") == FieldType.relation.value:
         preserved_reference = (
             deepcopy(field.get("_reference_config_template"))
-            if not bool(field.get("_relation_config_explicit")) and isinstance(field.get("_reference_config_template"), dict)
+            if not relation_config_explicit and isinstance(field.get("_reference_config_template"), dict)
             else None
         )
         if preserved_reference is not None:
             preserved_reference["referAppKey"] = field.get("target_app_key")
             question["referenceConfig"] = preserved_reference
         else:
-            reference = deepcopy(question.get("referenceConfig")) if isinstance(question.get("referenceConfig"), dict) else {}
+            reference = (
+                deepcopy(built_question.get("referenceConfig"))
+                if relation_config_explicit and isinstance(built_question.get("referenceConfig"), dict)
+                else deepcopy(question.get("referenceConfig"))
+                if isinstance(question.get("referenceConfig"), dict)
+                else {}
+            )
             built_reference = (
                 deepcopy(built_question.get("referenceConfig"))
                 if isinstance(built_question.get("referenceConfig"), dict)
                 else {}
             )
+            if relation_config_explicit:
+                for stale_key in ("customButtonText", "customAdvancedSetting", "configShowForm", "dataShowForm"):
+                    reference.pop(stale_key, None)
             for key in (
                 "referQueId",
                 "referQuestions",
@@ -13007,6 +13085,7 @@ def _build_form_payload_for_edit_fields(
     question_relations: list[dict[str, Any]] | None = None,
 ) -> dict[str, Any]:
     _, section_templates = _extract_question_templates(current_schema)
+    template_row_lengths_by_que_id, template_row_lengths_by_title = _extract_template_row_lengths(current_schema)
     fields_by_name = {
         str(field.get("name") or ""): field
         for field in fields
@@ -13017,18 +13096,26 @@ def _build_form_payload_for_edit_fields(
 
     for row in layout.get("root_rows", []) or []:
         questions: list[dict[str, Any]] = []
+        expected_template_lengths: list[int] = []
         row_preserved = True
         for name in row:
             field = fields_by_name.get(str(name))
             if field is None:
                 continue
+            template_row_length = _field_template_row_length(
+                field,
+                lengths_by_que_id=template_row_lengths_by_que_id,
+                lengths_by_title=template_row_lengths_by_title,
+            )
+            if template_row_length is not None:
+                expected_template_lengths.append(template_row_length)
             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:
+        if not row_preserved or _row_needs_width_reflow(expected_template_lengths, len(questions)):
             _apply_row_widths(questions)
         form_rows.append(questions)
 
@@ -13036,18 +13123,26 @@ def _build_form_payload_for_edit_fields(
         inner_rows: list[list[dict[str, Any]]] = []
         for row in section.get("rows", []) or []:
             questions: list[dict[str, Any]] = []
+            expected_template_lengths: list[int] = []
             row_preserved = True
             for name in row:
                 field = fields_by_name.get(str(name))
                 if field is None:
                     continue
+                template_row_length = _field_template_row_length(
+                    field,
+                    lengths_by_que_id=template_row_lengths_by_que_id,
+                    lengths_by_title=template_row_lengths_by_title,
+                )
+                if template_row_length is not None:
+                    expected_template_lengths.append(template_row_length)
                 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:
+            if not row_preserved or _row_needs_width_reflow(expected_template_lengths, len(questions)):
                 _apply_row_widths(questions)
             inner_rows.append(questions)
         if not inner_rows: