@josephyan/qingflow-app-user-mcp 0.2.0-beta.83 → 0.2.0-beta.85

package/README.md

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@josephyan/qingflow-app-user-mcp",
-  "version": "0.2.0-beta.83",
+  "version": "0.2.0-beta.85",
   "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.0b83"
+version = "0.2.0b85"
 description = "User-authenticated MCP server for Qingflow"
 readme = "README.md"
 license = "MIT"

package/src/qingflow_mcp/__init__.py

@@ -2,4 +2,4 @@ from __future__ import annotations
 
 __all__ = ["__version__"]
 
-__version__ = "0.2.0b83"
+__version__ = "0.2.0b85"

package/src/qingflow_mcp/builder_facade/service.py

@@ -450,6 +450,10 @@ class AiBuilderFacade:
                     "http_status": detail_read_error.http_status,
                 }
             )
+        public_items = _public_package_items_from_tag_items(source.get("tagItems") or base.get("tagItems"))
+        item_count = summary.get("itemCount")
+        if not isinstance(item_count, int) or item_count < 0 or (item_count == 0 and public_items):
+            item_count = len(public_items)
         return {
             "status": "success",
             "error_code": None,
@@ -469,13 +473,13 @@ class AiBuilderFacade:
             "package_name": str(source.get("tagName") or base.get("tagName") or "").strip() or None,
             "icon": str(source.get("tagIcon") or base.get("tagIcon") or "").strip() or None,
             "publish_status": source.get("publishStatus") if source.get("publishStatus") is not None else base.get("publishStatus"),
-            "item_count": summary.get("itemCount"),
+            "item_count": item_count,
             "add_app_status": base.get("addAppStatus") if base.get("addAppStatus") is not None else summary.get("addAppStatus"),
             "edit_app_status": base.get("editAppStatus") if base.get("editAppStatus") is not None else summary.get("editAppStatus"),
             "del_app_status": base.get("delAppStatus") if base.get("delAppStatus") is not None else summary.get("delAppStatus"),
             "edit_tag_status": base.get("editTagStatus") if base.get("editTagStatus") is not None else summary.get("editTagStatus"),
             "visibility": _public_visibility_from_member_auth(base.get("auth") or source.get("auth")),
-            "items": _public_package_items_from_tag_items(source.get("tagItems") or base.get("tagItems")),
+            "items": public_items,
         }
 
     def package_apply(
@@ -844,15 +848,18 @@ class AiBuilderFacade:
         allow_detach: bool,
         normalized_args: JSONObject,
     ) -> JSONObject:
-        current_result: JSONObject | None = None
+        current_detail_result: JSONObject | None = None
+        current_base_result: JSONObject | None = None
+        detail_api_error: QingflowApiError | None = None
         try:
-            current_result = self.packages.package_get(profile=profile, tag_id=package_id, include_raw=True)
+            current_detail_result = self.packages.package_get(profile=profile, tag_id=package_id, include_raw=True)
         except (QingflowApiError, RuntimeError) as detail_error:
             detail_api_error = _coerce_api_error(detail_error)
-            try:
-                current_result = self.packages.package_get_base(profile=profile, tag_id=package_id, include_raw=True)
-            except (QingflowApiError, RuntimeError) as base_error:
-                api_error = _coerce_api_error(base_error)
+        try:
+            current_base_result = self.packages.package_get_base(profile=profile, tag_id=package_id, include_raw=True)
+        except (QingflowApiError, RuntimeError) as base_error:
+            api_error = _coerce_api_error(base_error)
+            if current_detail_result is None:
                 return _failed_from_api_error(
                     "PACKAGE_LAYOUT_READ_FAILED",
                     api_error,
@@ -863,8 +870,20 @@ class AiBuilderFacade:
                     },
                     suggested_next_call={"tool_name": "package_get", "arguments": {"profile": profile, "package_id": package_id}},
                 )
-        current_raw = current_result.get("result") if isinstance(current_result.get("result"), dict) else {}
-        raw_tag_items = current_raw.get("tagItems")
+
+        detail_raw = (
+            current_detail_result.get("result")
+            if isinstance(current_detail_result, dict) and isinstance(current_detail_result.get("result"), dict)
+            else {}
+        )
+        base_raw = (
+            current_base_result.get("result")
+            if isinstance(current_base_result, dict) and isinstance(current_base_result.get("result"), dict)
+            else {}
+        )
+        detail_tag_items = detail_raw.get("tagItems") if isinstance(detail_raw.get("tagItems"), list) else None
+        base_tag_items = base_raw.get("tagItems") if isinstance(base_raw.get("tagItems"), list) else None
+        raw_tag_items = detail_tag_items if detail_tag_items else base_tag_items
         if not isinstance(raw_tag_items, list):
             return _failed(
                 "PACKAGE_LAYOUT_UNREADABLE",
@@ -875,8 +894,19 @@ class AiBuilderFacade:
             )
         current_items = raw_tag_items
 
+        current_group_specs = _collect_backend_package_group_specs(current_items)
+        normalized_items, group_resolution_issues = _align_public_package_group_ids(items, current_group_specs=current_group_specs)
+        if group_resolution_issues:
+            return _failed(
+                "PACKAGE_GROUP_AMBIGUOUS",
+                "items contains group names that match multiple existing package groups; pass explicit group_id to disambiguate",
+                normalized_args=normalized_args,
+                details={"package_id": package_id, "issues": group_resolution_issues},
+                suggested_next_call={"tool_name": "package_get", "arguments": {"profile": profile, "package_id": package_id}},
+            )
+
         current_resources = _flatten_package_resource_identities(current_items, public=False)
-        desired_resources = _flatten_package_resource_identities(items, public=True)
+        desired_resources = _flatten_package_resource_identities(normalized_items, public=True)
         missing_resources = sorted(current_resources - desired_resources)
         if missing_resources and not allow_detach:
             return _failed(
@@ -887,7 +917,7 @@ class AiBuilderFacade:
                 suggested_next_call=None,
             )
 
-        duplicate_resources = _find_duplicate_package_resources(items)
+        duplicate_resources = _find_duplicate_package_resources(normalized_items)
         if duplicate_resources:
             return _failed(
                 "PACKAGE_LAYOUT_DUPLICATE_ITEM",
@@ -897,8 +927,8 @@ class AiBuilderFacade:
                 suggested_next_call=None,
             )
 
-        current_groups = _collect_backend_package_groups(current_items)
-        desired_groups = _collect_public_package_group_specs(items)
+        current_groups = {int(spec["group_id"]): str(spec["name"] or "").strip() for spec in current_group_specs}
+        desired_groups = _collect_public_package_group_specs(normalized_items)
         desired_group_ids = {
             group_id for group_id in (_coerce_positive_int(group.get("group_id")) for group in desired_groups) if group_id is not None
         }
@@ -907,7 +937,7 @@ class AiBuilderFacade:
         permission_outcomes: list[PermissionCheckOutcome] = []
         needs_group_create = any(_coerce_positive_int(group.get("group_id")) is None for group in desired_groups)
         needs_group_delete = bool(deleted_group_ids)
-        needs_edit_app = bool(items)
+        needs_edit_app = bool(normalized_items)
         for required_permission in (
             (["add_app"] if needs_group_create else [])
             + (["edit_app"] if needs_edit_app else [])
@@ -975,7 +1005,7 @@ class AiBuilderFacade:
             group_ids_by_path[path] = group_id
 
         try:
-            backend_items = _backend_package_items_from_public_items(items, group_ids_by_path)
+            backend_items = _backend_package_items_from_public_items(normalized_items, group_ids_by_path)
         except ValueError as error:
             return _failed(
                 "PACKAGE_LAYOUT_INVALID",
@@ -984,8 +1014,6 @@ class AiBuilderFacade:
                 details={"package_id": package_id},
                 suggested_next_call=None,
             )
-        for group_id in deleted_group_ids:
-            backend_items.append({"itemType": 3, "groupId": group_id, "title": current_groups.get(group_id) or "", "subItems": []})
 
         try:
             sort_result = self.packages.package_sort_items(profile=profile, tag_id=package_id, tag_items=backend_items)
@@ -12419,22 +12447,36 @@ def _find_duplicate_package_resources(items: Any) -> list[tuple[str, str]]:
 
 
 def _collect_backend_package_groups(tag_items: Any) -> dict[int, str]:
-    groups: dict[int, str] = {}
+    return {
+        int(spec["group_id"]): str(spec["name"] or "").strip()
+        for spec in _collect_backend_package_group_specs(tag_items)
+        if _coerce_positive_int(spec.get("group_id")) is not None
+    }
 
-    def walk(value: Any) -> None:
-        if isinstance(value, list):
-            for child in value:
-                walk(child)
-            return
-        if not isinstance(value, dict):
-            return
-        if _coerce_positive_int(value.get("itemType")) == 3:
-            group_id = _coerce_positive_int(value.get("groupId"))
-            if group_id is not None:
-                groups[group_id] = str(value.get("title") or value.get("groupName") or "").strip()
-        walk(value.get("subItems"))
 
-    walk(tag_items)
+def _collect_backend_package_group_specs(tag_items: Any, *, path: tuple[int, ...] = ()) -> list[JSONObject]:
+    if not isinstance(tag_items, list):
+        return []
+    groups: list[JSONObject] = []
+    for index, item in enumerate(tag_items):
+        if not isinstance(item, dict):
+            continue
+        item_type = _coerce_positive_int(item.get("itemType"))
+        child_path = (*path, index)
+        if item_type == 3:
+            group_id = _coerce_positive_int(item.get("groupId"))
+            if group_id is None:
+                continue
+            child_items = item.get("subItems") if isinstance(item.get("subItems"), list) else []
+            groups.append(
+                {
+                    "path": list(child_path),
+                    "group_id": group_id,
+                    "name": str(item.get("title") or item.get("groupName") or "").strip(),
+                    "resource_signature": _package_resource_signature(child_items, public=False),
+                }
+            )
+            groups.extend(_collect_backend_package_group_specs(child_items, path=child_path))
     return groups
 
 
@@ -12459,6 +12501,91 @@ def _collect_public_package_group_specs(items: Any, *, path: tuple[int, ...] = (
     return groups
 
 
+def _align_public_package_group_ids(
+    items: list[dict[str, Any]],
+    *,
+    current_group_specs: list[JSONObject],
+) -> tuple[list[dict[str, Any]], list[JSONObject]]:
+    normalized_items = deepcopy(items)
+    used_group_ids: set[int] = set()
+    issues: list[JSONObject] = []
+
+    def walk(nodes: list[dict[str, Any]], *, path: tuple[int, ...] = ()) -> None:
+        for index, node in enumerate(nodes):
+            if not isinstance(node, dict):
+                continue
+            item_type = str(node.get("type") or "").strip().lower()
+            child_path = (*path, index)
+            child_items = node.get("items") if isinstance(node.get("items"), list) else []
+            if item_type == "group" or isinstance(node.get("items"), list):
+                explicit_group_id = _coerce_positive_int(node.get("group_id") or node.get("groupId"))
+                if explicit_group_id is not None:
+                    node["group_id"] = explicit_group_id
+                    used_group_ids.add(explicit_group_id)
+                else:
+                    group_name = str(node.get("name") or node.get("title") or node.get("group_name") or "").strip()
+                    matched_group, ambiguity = _match_existing_package_group(
+                        group_name=group_name,
+                        child_items=child_items,
+                        path=child_path,
+                        current_group_specs=current_group_specs,
+                        used_group_ids=used_group_ids,
+                    )
+                    if ambiguity is not None:
+                        issues.append(ambiguity)
+                    elif matched_group is not None:
+                        matched_group_id = _coerce_positive_int(matched_group.get("group_id"))
+                        if matched_group_id is not None:
+                            node["group_id"] = matched_group_id
+                            used_group_ids.add(matched_group_id)
+                walk(child_items, path=child_path)
+
+    walk(normalized_items)
+    return normalized_items, issues
+
+
+def _match_existing_package_group(
+    *,
+    group_name: str,
+    child_items: list[dict[str, Any]],
+    path: tuple[int, ...],
+    current_group_specs: list[JSONObject],
+    used_group_ids: set[int],
+) -> tuple[JSONObject | None, JSONObject | None]:
+    desired_signature = _package_resource_signature(child_items, public=True)
+    candidates = [
+        spec
+        for spec in current_group_specs
+        if _coerce_positive_int(spec.get("group_id")) is not None
+        and int(spec["group_id"]) not in used_group_ids
+        and str(spec.get("name") or "").strip() == group_name
+    ]
+    exact_matches = [spec for spec in candidates if spec.get("resource_signature") == desired_signature]
+    if len(exact_matches) == 1:
+        return exact_matches[0], None
+    path_matches = [spec for spec in candidates if tuple(spec.get("path") or ()) == path]
+    if len(path_matches) == 1:
+        return path_matches[0], None
+    if len(candidates) == 1:
+        return candidates[0], None
+    ambiguous_matches = exact_matches if len(exact_matches) > 1 else candidates if len(candidates) > 1 else []
+    if ambiguous_matches:
+        return None, {
+            "path": list(path),
+            "name": group_name,
+            "candidate_group_ids": [
+                int(spec["group_id"])
+                for spec in ambiguous_matches
+                if _coerce_positive_int(spec.get("group_id")) is not None
+            ],
+        }
+    return None, None
+
+
+def _package_resource_signature(items: Any, *, public: bool) -> tuple[tuple[str, str], ...]:
+    return tuple(sorted(_flatten_package_resource_identities(items, public=public)))
+
+
 def _backend_package_items_from_public_items(items: list[dict[str, Any]], group_ids_by_path: dict[tuple[int, ...], int], *, path: tuple[int, ...] = ()) -> list[JSONObject]:
     backend_items: list[JSONObject] = []
     for index, item in enumerate(items):