@josephyan/qingflow-app-builder-mcp 0.2.0-beta.1006 → 0.2.0-beta.1008

package/README.md

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@josephyan/qingflow-app-builder-mcp",
-  "version": "0.2.0-beta.1006",
+  "version": "0.2.0-beta.1008",
   "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 = "0.2.0b1006"
+version = "0.2.0b1008"
 description = "User-authenticated MCP server for Qingflow"
 readme = "README.md"
 license = "MIT"

package/src/qingflow_mcp/__init__.py

@@ -5,7 +5,7 @@ from pathlib import Path
 
 __all__ = ["__version__"]
 
-_FALLBACK_VERSION = "0.2.0b1006"
+_FALLBACK_VERSION = "0.2.0b1008"
 
 
 def _resolve_local_pyproject_version() -> str | None:

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

@@ -212,25 +212,15 @@ def _run_task_workbench_task_loop(args: argparse.Namespace, context: CliContext)
         detail_selection = _show_task_workbench_detail(args, task_context)
         if detail_selection.status == "cancelled":
             return "back", ""
-        if str(detail_selection.value or "") == "exit":
+        selected_value = str(detail_selection.value or "").strip()
+        if selected_value == "exit":
             return "result", cancelled_result("已退出")
-        if str(detail_selection.value or "") != "action":
+        if selected_value == "back":
             return "back", ""
-
-        action_selection = _choose_task_action_interactively(
-            args,
-            task_context,
-            fields={},
-            title=_build_task_action_title(task_context),
-        )
-        if action_selection.status == "cancelled":
-            continue
-        if action_selection.status == "empty":
+        if not selected_value:
             continue
-        if action_selection.status != "selected":
-            return "result", cancelled_result("已退出")
 
-        args.action = str(action_selection.value or "").strip()
+        args.action = selected_value
         payload_selection = _resolve_action_payload_or_select(args, task_context, payload={})
         if _is_cancelled_result(payload_selection):
             continue
@@ -421,35 +411,8 @@ def _choose_task_action_interactively(
     fields: dict[str, Any],
     title: str = "选择操作",
 ):
-    data = task_context.get("data") if isinstance(task_context.get("data"), dict) else {}
-    available_actions = [str(item).strip() for item in (data.get("available_actions") or []) if str(item).strip()]
-    extras = data.get("extras") if isinstance(data.get("extras"), dict) else {}
-    action_metadata = data.get("action_metadata") if isinstance(data.get("action_metadata"), dict) else {}
-    feedback_required = {
-        str(item).strip()
-        for item in (action_metadata.get("feedback_required_for") or [])
-        if str(item).strip()
-    }
-    rollback_count = _count_candidate_items(extras.get("rollback_candidates"))
-    transfer_count = _count_candidate_items(extras.get("transfer_candidates"))
-
     def load_options() -> list[SelectionOption[str]]:
-        options: list[SelectionOption[str]] = []
-        for action in available_actions:
-            if action == "save_only" and not fields:
-                continue
-            label = TASK_ACTION_LABELS.get(action, action)
-            hint_parts = [action]
-            if action in feedback_required:
-                hint_parts.append("需要理由")
-            if action == "rollback":
-                hint_parts.append(f"可退回节点 {rollback_count}")
-            if action == "transfer":
-                hint_parts.append(f"可转交成员 {transfer_count}")
-            if action == "save_only":
-                hint_parts.append("仅保存字段，不推进流程")
-            options.append(SelectionOption(value=action, label=label, hint=" · ".join(hint_parts)))
-        return options
+        return _task_interactive_action_options(task_context, fields=fields)
 
     return resolve_interactive_selection(
         args,
@@ -461,14 +424,11 @@ def _choose_task_action_interactively(
 
 
 def _show_task_workbench_detail(args: argparse.Namespace, task_context: dict[str, Any]):
-    has_actions = _task_has_interactive_actions(task_context)
-
     def load_options() -> list[SelectionOption[str]]:
-        if has_actions:
-            return [
-                SelectionOption(value="action", label="执行操作", hint="查看当前节点可执行动作"),
-                SelectionOption(value="back", label="返回列表", hint="回到待办列表"),
-            ]
+        options = _task_interactive_action_options(task_context, fields={})
+        if options:
+            options.append(SelectionOption(value="back", label="返回列表", hint="回到待办列表"))
+            return options
         return [
             SelectionOption(value="back", label="返回列表", hint="当前节点没有可执行动作"),
             SelectionOption(value="exit", label="退出工作台", hint="结束当前待办工作台"),
@@ -667,7 +627,9 @@ def _build_task_detail_title(task_context: dict[str, Any]) -> str:
     editable_fields = data.get("editable_fields") if isinstance(data.get("editable_fields"), list) else []
     extras = data.get("extras") if isinstance(data.get("extras"), dict) else {}
     initiator = task.get("initiator") if isinstance(task.get("initiator"), dict) else {}
+    all_fields = record_summary.get("all_fields") if isinstance(record_summary.get("all_fields"), dict) else {}
     core_fields = record_summary.get("core_fields") if isinstance(record_summary.get("core_fields"), dict) else {}
+    field_map = all_fields or core_fields
     action_labels = ", ".join(TASK_ACTION_LABELS.get(str(item), str(item)) for item in available_actions if str(item).strip()) or "-"
     lines = [
         "待办详情",
@@ -676,6 +638,8 @@ def _build_task_detail_title(task_context: dict[str, Any]) -> str:
         f"节点: {task.get('workflow_node_name') or '-'}",
         f"发起人: {_task_initiator_label(initiator)}",
         f"状态: {record_summary.get('apply_status') or '-'}",
+        f"申请编号: {record_summary.get('custom_apply_num') or record_summary.get('apply_num') or '-'}",
+        f"提交时间: {record_summary.get('apply_time') or '-'}",
         f"可执行动作: {action_labels}",
         f"可编辑字段: {len(editable_fields)}",
         (
@@ -685,18 +649,14 @@ def _build_task_detail_title(task_context: dict[str, Any]) -> str:
             f"转交 {_count_candidate_items(extras.get('transfer_candidates'))}"
         ),
     ]
-    if core_fields:
+    if field_map:
         lines.append("")
-        lines.append("摘要字段:")
-        for key, value in list(core_fields.items())[:6]:
-            lines.append(f"- {key}: {_short_display(value)}")
+        lines.append(f"字段值（{len(field_map)}）:")
+        for key, value in field_map.items():
+            lines.append(f"- {key}: {_full_display(value)}")
     return "\n".join(lines)
 
 
-def _build_task_action_title(task_context: dict[str, Any]) -> str:
-    return _build_task_detail_title(task_context) + "\n\n选择操作"
-
-
 def _task_initiator_label(initiator: dict[str, Any]) -> str:
     for key in ("display_name", "displayName", "name", "email", "uid"):
         value = initiator.get(key)
@@ -705,17 +665,44 @@ def _task_initiator_label(initiator: dict[str, Any]) -> str:
     return "-"
 
 
-def _task_has_interactive_actions(task_context: dict[str, Any]) -> bool:
+def _task_interactive_action_options(task_context: dict[str, Any], *, fields: dict[str, Any]) -> list[SelectionOption[str]]:
     data = task_context.get("data") if isinstance(task_context.get("data"), dict) else {}
     available_actions = [str(item).strip() for item in (data.get("available_actions") or []) if str(item).strip()]
-    return any(action != "save_only" for action in available_actions)
-
+    action_metadata = data.get("action_metadata") if isinstance(data.get("action_metadata"), dict) else {}
+    extras = data.get("extras") if isinstance(data.get("extras"), dict) else {}
+    feedback_required = {
+        str(item).strip()
+        for item in (action_metadata.get("feedback_required_for") or [])
+        if str(item).strip()
+    }
+    rollback_count = _count_candidate_items(extras.get("rollback_candidates"))
+    transfer_count = _count_candidate_items(extras.get("transfer_candidates"))
 
-def _short_display(value: Any, *, limit: int = 60) -> str:
-    text = str(value if value not in (None, "") else "-")
-    if len(text) <= limit:
-        return text
-    return text[: limit - 1] + "…"
+    options: list[SelectionOption[str]] = []
+    for action in available_actions:
+        if action == "save_only" and not fields:
+            continue
+        label = TASK_ACTION_LABELS.get(action, action)
+        hint_parts = [action]
+        if action in feedback_required:
+            hint_parts.append("需要理由")
+        if action == "rollback":
+            hint_parts.append(f"可退回节点 {rollback_count}")
+        if action == "transfer":
+            hint_parts.append(f"可转交成员 {transfer_count}")
+        if action == "save_only":
+            hint_parts.append("仅保存字段，不推进流程")
+        options.append(SelectionOption(value=action, label=label, hint=" · ".join(hint_parts)))
+    return options
+
+
+def _full_display(value: Any) -> str:
+    if value in (None, ""):
+        return "-"
+    if isinstance(value, list):
+        normalized = [str(item) for item in value if item not in (None, "")]
+        return " / ".join(normalized) if normalized else "-"
+    return str(value)
 
 
 def _has_interactive_terminal(args: argparse.Namespace) -> bool:

package/src/qingflow_mcp/cli/formatters.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import json
+import textwrap
 from typing import Any, TextIO
 
 
@@ -237,15 +238,22 @@ def _format_task_get(result: dict[str, Any]) -> str:
             f"App: {task.get('app_name') or '-'}",
             f"Initiator: {initiator_label}",
             f"Apply Status: {record_summary.get('apply_status')}",
+            f"Apply Number: {record_summary.get('custom_apply_num') or record_summary.get('apply_num') or '-'}",
+            f"Apply Time: {record_summary.get('apply_time') or '-'}",
             f"Available Actions: {', '.join(str(item) for item in available_actions) or '-'}",
             f"Editable Fields: {len(editable_fields)}",
         ]
     )
+    all_fields = record_summary.get("all_fields") if isinstance(record_summary.get("all_fields"), dict) else {}
     core_fields = record_summary.get("core_fields") if isinstance(record_summary.get("core_fields"), dict) else {}
-    if core_fields:
+    if all_fields:
+        lines.append("Fields:")
+        for key, value in all_fields.items():
+            lines.extend(_format_field_line(key, value))
+    elif core_fields:
         lines.append("Core Fields:")
         for key, value in list(core_fields.items())[:12]:
-            lines.append(f"- {key}: {value}")
+            lines.extend(_format_field_line(key, value))
     if editable_fields:
         lines.append("Editable Fields:")
         for item in editable_fields[:10]:
@@ -303,6 +311,23 @@ def _format_task_workbench(result: dict[str, Any]) -> str:
     return ""
 
 
+def _format_field_line(key: Any, value: Any) -> list[str]:
+    if isinstance(value, list):
+        text = " / ".join(str(item) for item in value if item not in (None, ""))
+    else:
+        text = str(value if value not in (None, "") else "-")
+    wrapped = textwrap.wrap(
+        text,
+        width=120,
+        initial_indent=f"- {key}: ",
+        subsequent_indent="  ",
+        replace_whitespace=False,
+        drop_whitespace=False,
+        break_long_words=True,
+    )
+    return wrapped or [f"- {key}: -"]
+
+
 def _format_task_associated_report_detail(result: dict[str, Any]) -> str:
     data = result.get("data") if isinstance(result.get("data"), dict) else {}
     selection = data.get("selection") if isinstance(data.get("selection"), dict) else {}

package/src/qingflow_mcp/cli/terminal_ui.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 import os
 import select
 import shutil
+import textwrap
 from dataclasses import dataclass
 from typing import Generic, Sequence, TextIO, TypeVar
 
@@ -165,7 +166,33 @@ def _truncate_line(text: str, *, width: int) -> str:
 
 def _render_multiline_text(text: str, *, width: int) -> list[str]:
     parts = text.splitlines() or [text]
-    return [_truncate_line(part, width=width) for part in parts]
+    rendered: list[str] = []
+    wrap_width = max(1, width)
+    for part in parts:
+        if not part:
+            rendered.append("")
+            continue
+        initial_indent = ""
+        subsequent_indent = ""
+        stripped = part.lstrip()
+        if stripped.startswith("- "):
+            leading_spaces = len(part) - len(stripped)
+            initial_indent = part[:leading_spaces] + "- "
+            subsequent_indent = part[:leading_spaces] + "  "
+            content = stripped[2:]
+        else:
+            content = part
+        wrapped = textwrap.wrap(
+            content,
+            width=wrap_width,
+            initial_indent=initial_indent,
+            subsequent_indent=subsequent_indent,
+            replace_whitespace=False,
+            drop_whitespace=False,
+            break_long_words=True,
+        )
+        rendered.extend(wrapped or [""])
+    return rendered
 
 
 def _read_key(input_stream: TextIO) -> str:

package/src/qingflow_mcp/tools/task_context_tools.py

@@ -1762,6 +1762,7 @@ class TaskContextTools(ToolBase):
                 "apply_time": record.get("apply_time"),
                 "last_update_time": record.get("last_update_time"),
                 "core_fields": self._task_record_core_fields(record.get("answers") or []),
+                "all_fields": self._task_record_all_fields(record.get("answers") or []),
             },
             "available_actions": available_actions,
             "editable_fields": [
@@ -1921,9 +1922,21 @@ class TaskContextTools(ToolBase):
         return None
 
     def _task_record_core_fields(self, answers: Any, *, limit: int = 12) -> dict[str, Any]:
+        return self._task_record_field_map(answers, limit=limit, truncate_text=160)
+
+    def _task_record_all_fields(self, answers: Any) -> dict[str, Any]:
+        return self._task_record_field_map(answers, limit=None, truncate_text=None)
+
+    def _task_record_field_map(
+        self,
+        answers: Any,
+        *,
+        limit: int | None,
+        truncate_text: int | None,
+    ) -> dict[str, Any]:
         if not isinstance(answers, list):
             return {}
-        core_fields: dict[str, Any] = {}
+        field_map: dict[str, Any] = {}
         for answer in answers:
             if not isinstance(answer, dict):
                 continue
@@ -1943,19 +1956,24 @@ class TaskContextTools(ToolBase):
                 value = values[0] if len(values) == 1 else values
             if value in (None, "", []):
                 continue
-            core_fields[str(title)] = self._compact_task_value(value)
-            if len(core_fields) >= limit:
+            field_map[str(title)] = self._compact_task_value(value, truncate_text=truncate_text)
+            if limit is not None and len(field_map) >= limit:
                 break
-        return core_fields
+        return field_map
 
-    def _compact_task_value(self, value: Any) -> Any:
+    def _compact_task_value(self, value: Any, *, truncate_text: int | None = 160) -> Any:
         if isinstance(value, list):
-            return [self._compact_task_value(item) for item in value[:8]]
+            items = [self._compact_task_value(item, truncate_text=truncate_text) for item in value]
+            if truncate_text is not None:
+                return items[:8]
+            return items
         text = re.sub(r"<[^>]+>", " ", str(value))
         text = re.sub(r"\s+", " ", text).strip()
-        if len(text) <= 160:
+        if truncate_text is None or len(text) <= truncate_text:
             return text
-        return text[:157].rstrip() + "..."
+        if truncate_text <= 3:
+            return text[:truncate_text]
+        return text[: truncate_text - 3].rstrip() + "..."
 
     def _compact_task_editable_field(self, field: dict[str, Any], update_schema: dict[str, Any]) -> dict[str, Any]:
         payload_template = update_schema.get("payload_template") if isinstance(update_schema.get("payload_template"), dict) else {}