@josephyan/qingflow-app-builder-mcp 0.2.0-beta.997 → 0.2.0-beta.999

package/README.md

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@josephyan/qingflow-app-builder-mcp",
-  "version": "0.2.0-beta.997",
+  "version": "0.2.0-beta.999",
   "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.0b997"
+version = "0.2.0b999"
 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.0b997"
+_FALLBACK_VERSION = "0.2.0b999"
 
 
 def _resolve_local_pyproject_version() -> str | None:

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

@@ -1,8 +1,10 @@
 from __future__ import annotations
 
 import argparse
+import json
 
 from ..context import CliContext
+from ..terminal_ui import SelectionOption, select_option
 
 
 def register(subparsers: argparse._SubParsersAction[argparse.ArgumentParser]) -> None:
@@ -20,7 +22,7 @@ def register(subparsers: argparse._SubParsersAction[argparse.ArgumentParser]) ->
     get_parser.set_defaults(handler=_handle_get, format_hint="workspace_get")
 
     select_parser = workspace_subparsers.add_parser("select", help="切换当前工作区")
-    select_parser.add_argument("--ws-id", type=int, required=True)
+    select_parser.add_argument("--ws-id", type=int, default=0, help="不传时在交互终端中选择工作区")
     select_parser.set_defaults(handler=_handle_select, format_hint="workspace_get")
 
 
@@ -41,7 +43,68 @@ def _handle_get(args: argparse.Namespace, context: CliContext) -> dict:
 
 
 def _handle_select(args: argparse.Namespace, context: CliContext) -> dict:
+    if int(args.ws_id or 0) <= 0:
+        selected_ws_id = _choose_workspace_interactively(args, context)
+        if selected_ws_id is None:
+            raise RuntimeError(
+                json.dumps(
+                    {
+                        "category": "config",
+                        "message": "workspace select requires --ws-id, or an interactive terminal to choose a workspace",
+                    },
+                    ensure_ascii=False,
+                )
+            )
+        args.ws_id = selected_ws_id
     return context.workspace.workspace_select(
         profile=args.profile,
         ws_id=int(args.ws_id),
     )
+
+
+def _choose_workspace_interactively(args: argparse.Namespace, context: CliContext) -> int | None:
+    input_stream = getattr(args, "_stdin", None)
+    output_stream = getattr(args, "_stderr_stream", None)
+    if input_stream is None or output_stream is None:
+        return None
+    if not bool(getattr(input_stream, "isatty", lambda: False)()):
+        return None
+    page = context.workspace.workspace_list(
+        profile=args.profile,
+        page_num=1,
+        page_size=100,
+        include_external=False,
+    ).get("page")
+    items = page.get("list") if isinstance(page, dict) and isinstance(page.get("list"), list) else []
+    if not items:
+        return None
+    current_ws_id = None
+    sessions = getattr(context, "sessions", None)
+    if sessions is not None and hasattr(sessions, "get_profile"):
+        try:
+            session_profile = sessions.get_profile(args.profile)
+        except Exception:
+            session_profile = None
+        current_ws_id = getattr(session_profile, "selected_ws_id", None) if session_profile is not None else None
+    options: list[SelectionOption[int]] = []
+    for item in items:
+        if not isinstance(item, dict):
+            continue
+        ws_id = int(item.get("wsId") or 0)
+        if ws_id <= 0:
+            continue
+        workspace_name = str(item.get("workspaceName") or item.get("wsName") or f"Workspace {ws_id}")
+        remark = str(item.get("remark") or "").strip()
+        label = workspace_name
+        if remark:
+            label = f"{workspace_name} - {remark}"
+        hint = f"ws_id={ws_id}"
+        if current_ws_id == ws_id:
+            hint += " · 当前"
+        options.append(SelectionOption(value=ws_id, label=label, hint=hint))
+    return select_option(
+        title="选择工作区",
+        options=options,
+        input_stream=input_stream,
+        output_stream=output_stream,
+    )

package/src/qingflow_mcp/cli/main.py

@@ -44,6 +44,9 @@ def run(
         args = parser.parse_args(normalized_argv)
     except SystemExit as exc:
         return int(exc.code or 0)
+    setattr(args, "_stdin", sys.stdin)
+    setattr(args, "_stdout_stream", out)
+    setattr(args, "_stderr_stream", err)
     handler = getattr(args, "handler", None)
     if handler is None:
         parser.print_help(out)

package/src/qingflow_mcp/cli/terminal_ui.py

@@ -0,0 +1,172 @@
+from __future__ import annotations
+
+import os
+import select
+import shutil
+from dataclasses import dataclass
+from typing import Generic, Sequence, TextIO, TypeVar
+
+try:
+    import termios
+    import tty
+except ImportError:  # pragma: no cover - non-POSIX fallback
+    termios = None
+    tty = None
+
+
+T = TypeVar("T")
+
+
+@dataclass(slots=True)
+class SelectionOption(Generic[T]):
+    value: T
+    label: str
+    hint: str | None = None
+
+
+def select_option(
+    *,
+    title: str,
+    options: Sequence[SelectionOption[T]],
+    input_stream: TextIO,
+    output_stream: TextIO,
+    page_size: int = 8,
+) -> T | None:
+    if not options:
+        return None
+    if len(options) == 1:
+        return options[0].value
+    if not _supports_raw_selection(input_stream=input_stream, output_stream=output_stream):
+        return _select_option_via_prompt(title=title, options=options, input_stream=input_stream, output_stream=output_stream)
+    return _select_option_via_raw_terminal(
+        title=title,
+        options=options,
+        input_stream=input_stream,
+        output_stream=output_stream,
+        page_size=max(3, page_size),
+    )
+
+
+def _supports_raw_selection(*, input_stream: TextIO, output_stream: TextIO) -> bool:
+    if termios is None or tty is None:
+        return False
+    if not bool(getattr(input_stream, "isatty", lambda: False)()) or not bool(getattr(output_stream, "isatty", lambda: False)()):
+        return False
+    return hasattr(input_stream, "fileno")
+
+
+def _select_option_via_prompt(
+    *,
+    title: str,
+    options: Sequence[SelectionOption[T]],
+    input_stream: TextIO,
+    output_stream: TextIO,
+) -> T | None:
+    output_stream.write(title + "\n")
+    for index, option in enumerate(options, start=1):
+        suffix = f" ({option.hint})" if option.hint else ""
+        output_stream.write(f"{index}. {option.label}{suffix}\n")
+    output_stream.write("请输入编号并回车，留空取消: ")
+    output_stream.flush()
+    line = input_stream.readline()
+    selected = str(line or "").strip()
+    if not selected:
+        return None
+    if not selected.isdigit():
+        return None
+    index = int(selected) - 1
+    if index < 0 or index >= len(options):
+        return None
+    return options[index].value
+
+
+def _select_option_via_raw_terminal(
+    *,
+    title: str,
+    options: Sequence[SelectionOption[T]],
+    input_stream: TextIO,
+    output_stream: TextIO,
+    page_size: int,
+) -> T | None:
+    fd = input_stream.fileno()
+    original_mode = termios.tcgetattr(fd)
+    selected_index = 0
+    output_stream.write("\x1b[?1049h\x1b[?25l")
+    output_stream.flush()
+    try:
+        tty.setraw(fd)
+        while True:
+            _render_options(
+                title=title,
+                options=options,
+                selected_index=selected_index,
+                output_stream=output_stream,
+                page_size=page_size,
+            )
+            key = _read_key(input_stream)
+            if key in ("\r", "\n"):
+                return options[selected_index].value
+            if key in ("\x03", "\x1b", "q", "Q"):
+                return None
+            if key in ("\x1b[A", "k", "K"):
+                selected_index = (selected_index - 1) % len(options)
+                continue
+            if key in ("\x1b[B", "j", "J"):
+                selected_index = (selected_index + 1) % len(options)
+    finally:
+        termios.tcsetattr(fd, termios.TCSADRAIN, original_mode)
+        output_stream.write("\x1b[?25h\x1b[?1049l")
+        output_stream.flush()
+
+
+def _render_options(
+    *,
+    title: str,
+    options: Sequence[SelectionOption[object]],
+    selected_index: int,
+    output_stream: TextIO,
+    page_size: int,
+) -> None:
+    terminal_width = shutil.get_terminal_size((100, 20)).columns
+    total = len(options)
+    page_start = max(0, min(selected_index - page_size // 2, max(total - page_size, 0)))
+    visible = options[page_start: page_start + page_size]
+    lines = [
+        title,
+        "↑/↓ 或 j/k 选择，Enter 确认，q / Esc 取消",
+        "",
+    ]
+    for offset, option in enumerate(visible, start=page_start):
+        marker = ">" if offset == selected_index else " "
+        suffix = f"  [{option.hint}]" if option.hint else ""
+        lines.append(_truncate_line(f"{marker} {option.label}{suffix}", width=terminal_width))
+    if total > page_size:
+        lines.append("")
+        lines.append(f"{selected_index + 1}/{total}")
+    output_stream.write("\x1b[2J\x1b[H")
+    output_stream.write("\n".join(lines))
+    output_stream.flush()
+
+
+def _truncate_line(text: str, *, width: int) -> str:
+    if width <= 0 or len(text) <= width:
+        return text
+    if width <= 1:
+        return text[:width]
+    return text[: width - 1] + "…"
+
+
+def _read_key(input_stream: TextIO) -> str:
+    first = input_stream.read(1)
+    if first != "\x1b":
+        return first
+    chunks = [first]
+    fd = input_stream.fileno()
+    while select.select([fd], [], [], 0.02)[0]:
+        chunk = os.read(fd, 1).decode("utf-8", errors="ignore")
+        if not chunk:
+            break
+        chunks.append(chunk)
+        if len(chunks) >= 3:
+            break
+    return "".join(chunks)

package/src/qingflow_mcp/tools/task_context_tools.py

@@ -1148,53 +1148,61 @@ class TaskContextTools(ToolBase):
             "reported_total": matched_total,
         }
 
-    def _resolve_todo_task_locator(self, *, profile: str, task_id: Any) -> dict[str, Any]:
+    def _resolve_task_locator_by_task_id(self, *, profile: str, task_id: Any) -> dict[str, Any]:
         task_id_text = normalize_positive_id_text(task_id, field_name="task_id")
-        page = 1
+        searched_task_boxes = ("todo", "initiated", "cc", "done")
+        incomplete_task_boxes: list[str] = []
         page_size = 100
-        page_amount: int | None = None
-        while True:
-            response = self._list_normalized_task_items(
-                profile=profile,
-                task_box="todo",
-                flow_status="all",
-                app_key=None,
-                workflow_node_id=None,
-                query=None,
-                page=page,
-                page_size=page_size,
+        for task_box in searched_task_boxes:
+            page = 1
+            page_amount: int | None = None
+            while True:
+                response = self._list_normalized_task_items(
+                    profile=profile,
+                    task_box=task_box,
+                    flow_status="all",
+                    app_key=None,
+                    workflow_node_id=None,
+                    query=None,
+                    page=page,
+                    page_size=page_size,
+                )
+                items = response.get("items") if isinstance(response.get("items"), list) else []
+                for item in items:
+                    if not isinstance(item, dict) or not ids_equal(item.get("task_id"), task_id_text):
+                        continue
+                    app_key = str(item.get("app_key") or "").strip()
+                    record_id = stringify_backend_id(item.get("record_id"))
+                    workflow_node_id = int(item.get("workflow_node_id") or 0)
+                    if not app_key or record_id is None or workflow_node_id <= 0:
+                        incomplete_task_boxes.append(task_box)
+                        continue
+                    return {
+                        "task_id": task_id_text,
+                        "task_box": task_box,
+                        "app_key": app_key,
+                        "record_id": record_id,
+                        "workflow_node_id": workflow_node_id,
+                    }
+                if page_amount is None:
+                    coerced_page_amount = _coerce_count(response.get("page_amount"))
+                    if coerced_page_amount is not None and coerced_page_amount > 0:
+                        page_amount = coerced_page_amount
+                if page_amount is not None and page >= page_amount:
+                    break
+                if not items or len(items) < page_size:
+                    break
+                page += 1
+        if incomplete_task_boxes:
+            searched = ", ".join(incomplete_task_boxes)
+            raise_tool_error(
+                QingflowApiError.config_error(
+                    f"task_id={task_id_text} resolved to an incomplete task locator in task_box={searched}; please refresh the task list and retry"
+                )
             )
-            items = response.get("items") if isinstance(response.get("items"), list) else []
-            for item in items:
-                if not isinstance(item, dict) or not ids_equal(item.get("task_id"), task_id_text):
-                    continue
-                app_key = str(item.get("app_key") or "").strip()
-                record_id = stringify_backend_id(item.get("record_id"))
-                workflow_node_id = int(item.get("workflow_node_id") or 0)
-                if not app_key or record_id is None or workflow_node_id <= 0:
-                    raise_tool_error(
-                        QingflowApiError.config_error(
-                            f"task_id={task_id_text} resolved to an incomplete task locator; please refresh the todo list and retry"
-                        )
-                    )
-                return {
-                    "task_id": task_id_text,
-                    "app_key": app_key,
-                    "record_id": record_id,
-                    "workflow_node_id": workflow_node_id,
-                }
-            if page_amount is None:
-                coerced_page_amount = _coerce_count(response.get("page_amount"))
-                if coerced_page_amount is not None and coerced_page_amount > 0:
-                    page_amount = coerced_page_amount
-            if page_amount is not None and page >= page_amount:
-                break
-            if not items or len(items) < page_size:
-                break
-            page += 1
         raise_tool_error(
             QingflowApiError.config_error(
-                f"task_id={task_id_text} was not found in the current todo list; task context tools currently resolve actionable todo tasks by task_id"
+                f"task_id={task_id_text} was not found in the current visible task boxes (todo, initiated, cc, done)"
             )
         )
 
@@ -1212,7 +1220,7 @@ class TaskContextTools(ToolBase):
         resolved_record_id: int
         resolved_workflow_node_id: int
         if task_id_text is not None:
-            locator = self._resolve_todo_task_locator(profile=profile, task_id=task_id_text)
+            locator = self._resolve_task_locator_by_task_id(profile=profile, task_id=task_id_text)
             resolved_app_key = str(locator["app_key"])
             resolved_record_id = normalize_positive_id_int(locator["record_id"], field_name="record_id")
             resolved_workflow_node_id = int(locator["workflow_node_id"])