@josephyan/qingflow-cli 0.2.0-beta.58 → 0.2.0-beta.60

package/src/qingflow_mcp/ops/base.py

@@ -1,290 +0,0 @@
-from __future__ import annotations
-
-import json
-from typing import Any
-
-from ..errors import QingflowApiError
-from ..json_types import JSONObject
-
-
-_COMMON_KEYS = {
-    "ok",
-    "status",
-    "message",
-    "error_code",
-    "details",
-    "warnings",
-    "verification",
-    "profile",
-    "ws_id",
-    "request_id",
-    "request_route",
-    "output_profile",
-    "recoverable",
-    "missing_fields",
-    "allowed_values",
-    "suggested_next_call",
-    "noop",
-    "compact",
-    "summary",
-}
-
-_INTERNAL_LEGACY_KEY = "__legacy__"
-
-
-def success_result(
-    code: str,
-    message: str,
-    *,
-    data: Any = None,
-    warnings: list[Any] | None = None,
-    meta: JSONObject | None = None,
-    legacy: Any = None,
-) -> JSONObject:
-    payload: JSONObject = {
-        "ok": True,
-        "code": code,
-        "message": message,
-        "data": data if data is not None else {},
-        "warnings": list(warnings or []),
-        "meta": dict(meta or {}),
-    }
-    if legacy is not None:
-        payload[_INTERNAL_LEGACY_KEY] = legacy
-    return payload
-
-
-def error_result(
-    code: str,
-    message: str,
-    *,
-    details: Any = None,
-    suggested_next: Any = None,
-    meta: JSONObject | None = None,
-    legacy: Any = None,
-) -> JSONObject:
-    payload: JSONObject = {
-        "ok": False,
-        "code": code,
-        "message": message,
-        "details": details if details is not None else {},
-        "meta": dict(meta or {}),
-    }
-    if suggested_next is not None:
-        payload["suggested_next"] = suggested_next
-    if legacy is not None:
-        payload[_INTERNAL_LEGACY_KEY] = legacy
-    return payload
-
-
-def build_meta(raw: Any, *, extra: JSONObject | None = None) -> JSONObject:
-    meta: JSONObject = {}
-    if isinstance(raw, dict):
-        if raw.get("profile") is not None:
-            meta["profile"] = raw.get("profile")
-        if raw.get("ws_id") is not None:
-            meta["workspace_id"] = raw.get("ws_id")
-        if raw.get("request_id") is not None:
-            meta["request_id"] = raw.get("request_id")
-        if isinstance(raw.get("request_route"), dict):
-            meta["request_route"] = raw.get("request_route")
-        if isinstance(raw.get("verification"), dict) and raw.get("verification"):
-            meta["verification"] = raw.get("verification")
-    if extra:
-        meta.update(extra)
-    return meta
-
-
-def collect_warnings(raw: Any) -> list[Any]:
-    warnings: list[Any] = []
-    if isinstance(raw, dict):
-        if isinstance(raw.get("warnings"), list):
-            warnings.extend(raw["warnings"])
-        status = str(raw.get("status") or "").lower()
-        if status == "partial_success":
-            warnings.append(
-                {
-                    "code": "PARTIAL_SUCCESS",
-                    "message": str(raw.get("message") or "operation completed with warnings"),
-                }
-            )
-    return warnings
-
-
-def tool_payload(raw: Any) -> Any:
-    if not isinstance(raw, dict):
-        return raw
-    if "data" in raw:
-        return raw.get("data")
-    if "items" in raw:
-        return {
-            "items": raw.get("items") if isinstance(raw.get("items"), list) else [],
-            "count": raw.get("count"),
-        }
-    if "page" in raw:
-        page = raw.get("page")
-        if isinstance(page, dict):
-            return {
-                "items": page.get("list") if isinstance(page.get("list"), list) else [],
-                "page": page,
-            }
-    if "result" in raw:
-        return raw.get("result")
-    return {key: value for key, value in raw.items() if key not in _COMMON_KEYS}
-
-
-def is_failed_tool_result(raw: Any) -> bool:
-    if not isinstance(raw, dict):
-        return False
-    if raw.get("ok") is False:
-        return True
-    status = str(raw.get("status") or "").lower()
-    return status in {"failed", "blocked"}
-
-
-def tool_result_to_cli(
-    raw: Any,
-    *,
-    code: str,
-    message: str,
-    data: Any = None,
-    meta: JSONObject | None = None,
-) -> JSONObject:
-    if is_failed_tool_result(raw):
-        payload = normalize_tool_error(raw)
-        payload["meta"] = build_meta(raw, extra=meta)
-        return payload
-    return success_result(
-        code,
-        message,
-        data=tool_payload(raw) if data is None else data,
-        warnings=collect_warnings(raw),
-        meta=build_meta(raw, extra=meta),
-    )
-
-
-def normalize_tool_error(raw: Any) -> JSONObject:
-    if isinstance(raw, dict):
-        details = raw.get("details")
-        if not isinstance(details, dict):
-            details = {}
-        if raw.get("backend_code") is not None:
-            details.setdefault("backend_code", raw.get("backend_code"))
-        if raw.get("request_id") is not None:
-            details.setdefault("request_id", raw.get("request_id"))
-        if raw.get("verification") not in (None, {}):
-            details.setdefault("verification", raw.get("verification"))
-        return error_result(
-            str(raw.get("error_code") or raw.get("code") or raw.get("category") or "OPERATION_FAILED"),
-            str(raw.get("message") or "operation failed"),
-            details=details,
-            suggested_next=raw.get("suggested_next_call"),
-            legacy=raw,
-        )
-    return error_result("OPERATION_FAILED", str(raw))
-
-
-def coerce_runtime_error(exc: RuntimeError) -> QingflowApiError:
-    raw = str(exc)
-    try:
-        payload = json.loads(raw)
-    except json.JSONDecodeError:
-        return QingflowApiError(category="runtime", message=raw)
-    if not isinstance(payload, dict):
-        return QingflowApiError(category="runtime", message=raw)
-    return QingflowApiError(
-        category=str(payload.get("category") or "runtime"),
-        message=str(payload.get("message") or raw),
-        backend_code=payload.get("backend_code"),
-        request_id=payload.get("request_id"),
-        details=payload.get("details") if isinstance(payload.get("details"), dict) else None,
-    )
-
-
-def normalize_exception(error: Exception) -> JSONObject:
-    if isinstance(error, RuntimeError):
-        api_error = coerce_runtime_error(error)
-    elif isinstance(error, QingflowApiError):
-        api_error = error
-    else:
-        return error_result("RUNTIME_ERROR", str(error))
-
-    details = dict(api_error.details or {})
-    if api_error.backend_code is not None:
-        details.setdefault("backend_code", api_error.backend_code)
-    if api_error.request_id is not None:
-        details.setdefault("request_id", api_error.request_id)
-    code = str(details.pop("error_code", None) or api_error.category or "OPERATION_FAILED").upper()
-    if code == "CONFIG":
-        code = "INVALID_ARGUMENT"
-    elif code == "AUTH":
-        code = "AUTH_REQUIRED"
-    elif code == "WORKSPACE":
-        code = "WORKSPACE_NOT_SELECTED"
-    legacy_payload = None
-    if isinstance(error, RuntimeError):
-        raw = str(error)
-        try:
-            parsed = json.loads(raw)
-        except json.JSONDecodeError:
-            parsed = None
-        if isinstance(parsed, dict):
-            legacy_payload = parsed
-    return error_result(code, api_error.message, details=details, legacy=legacy_payload)
-
-
-def public_result(payload: Any) -> Any:
-    if isinstance(payload, dict):
-        return {
-            key: public_result(value)
-            for key, value in payload.items()
-            if key != _INTERNAL_LEGACY_KEY
-        }
-    if isinstance(payload, list):
-        return [public_result(item) for item in payload]
-    return payload
-
-
-def mcp_result_from_operation(result: Any) -> Any:
-    if not isinstance(result, dict):
-        return result
-    legacy = result.get(_INTERNAL_LEGACY_KEY)
-    if isinstance(legacy, dict):
-        return legacy
-    meta = result.get("meta") if isinstance(result.get("meta"), dict) else {}
-    if result.get("ok") is False:
-        payload: JSONObject = {
-            "ok": False,
-            "status": "failed",
-            "error_code": result.get("code") or "OPERATION_FAILED",
-            "message": result.get("message") or "operation failed",
-            "details": result.get("details") if isinstance(result.get("details"), dict) else {},
-            "warnings": result.get("warnings") if isinstance(result.get("warnings"), list) else [],
-        }
-        if isinstance(meta.get("request_route"), dict):
-            payload["request_route"] = meta["request_route"]
-        if isinstance(meta.get("verification"), dict):
-            payload["verification"] = meta["verification"]
-        if meta.get("profile") is not None:
-            payload["profile"] = meta.get("profile")
-        if meta.get("workspace_id") is not None:
-            payload["ws_id"] = meta.get("workspace_id")
-        if result.get("suggested_next") is not None:
-            payload["suggested_next_call"] = result.get("suggested_next")
-        return payload
-    payload = {
-        "ok": True,
-        "status": "success",
-        "message": result.get("message") or "ok",
-        "data": result.get("data"),
-        "warnings": result.get("warnings") if isinstance(result.get("warnings"), list) else [],
-    }
-    if isinstance(meta.get("request_route"), dict):
-        payload["request_route"] = meta["request_route"]
-    if isinstance(meta.get("verification"), dict):
-        payload["verification"] = meta["verification"]
-    if meta.get("profile") is not None:
-        payload["profile"] = meta.get("profile")
-    if meta.get("workspace_id") is not None:
-        payload["ws_id"] = meta.get("workspace_id")
-    return payload

package/src/qingflow_mcp/ops/builder.py

@@ -1,357 +0,0 @@
-from __future__ import annotations
-
-from typing import Any
-
-from .base import normalize_tool_error, success_result, tool_payload
-
-
-class BuilderOperations:
-    def __init__(self, tools: Any) -> None:
-        self._tools = tools
-
-    def package_list(self, *, profile: str, trial_status: str) -> dict:
-        return self._call("PACKAGES_READY", "已读取应用包列表", self._tools.builder.package_list(profile=profile, trial_status=trial_status))
-
-    def package_resolve(self, *, profile: str, package_name: str) -> dict:
-        return self._call("PACKAGE_RESOLVED", "已解析应用包", self._tools.builder.package_resolve(profile=profile, package_name=package_name))
-
-    def builder_tool_contract(self, *, tool_name: str) -> dict:
-        return self._call("BUILDER_TOOL_CONTRACT_READY", "已读取工具契约", self._tools.builder.builder_tool_contract(tool_name=tool_name))
-
-    def package_create(self, *, profile: str, package_name: str) -> dict:
-        return self._call("PACKAGE_CREATED", "已创建应用包", self._tools.builder.package_create(profile=profile, package_name=package_name))
-
-    def member_search(
-        self,
-        *,
-        profile: str,
-        query: str,
-        page_num: int,
-        page_size: int,
-        contain_disable: bool,
-    ) -> dict:
-        return self._call(
-            "MEMBERS_READY",
-            "已读取成员候选",
-            self._tools.builder.member_search(
-                profile=profile,
-                query=query,
-                page_num=page_num,
-                page_size=page_size,
-                contain_disable=contain_disable,
-            ),
-        )
-
-    def role_search(self, *, profile: str, keyword: str, page_num: int, page_size: int) -> dict:
-        return self._call(
-            "ROLES_READY",
-            "已读取角色候选",
-            self._tools.builder.role_search(profile=profile, keyword=keyword, page_num=page_num, page_size=page_size),
-        )
-
-    def role_create(
-        self,
-        *,
-        profile: str,
-        role_name: str,
-        member_uids: list[int],
-        member_emails: list[str],
-        member_names: list[str],
-        role_icon: str,
-    ) -> dict:
-        return self._call(
-            "ROLE_CREATED",
-            "已创建角色",
-            self._tools.builder.role_create(
-                profile=profile,
-                role_name=role_name,
-                member_uids=member_uids,
-                member_emails=member_emails,
-                member_names=member_names,
-                role_icon=role_icon,
-            ),
-        )
-
-    def package_attach_app(self, *, profile: str, tag_id: int, app_key: str, app_title: str) -> dict:
-        return self._call(
-            "PACKAGE_APP_ATTACHED",
-            "已挂载应用到应用包",
-            self._tools.builder.package_attach_app(profile=profile, tag_id=tag_id, app_key=app_key, app_title=app_title),
-        )
-
-    def release_edit_lock_if_mine(
-        self,
-        *,
-        profile: str,
-        app_key: str,
-        lock_owner_email: str,
-        lock_owner_name: str,
-    ) -> dict:
-        return self._call(
-            "APP_EDIT_LOCK_RELEASED",
-            "已释放编辑锁",
-            self._tools.builder.app_release_edit_lock_if_mine(
-                profile=profile,
-                app_key=app_key,
-                lock_owner_email=lock_owner_email,
-                lock_owner_name=lock_owner_name,
-            ),
-        )
-
-    def app_resolve(self, *, profile: str, app_key: str, app_name: str, package_tag_id: int | None) -> dict:
-        return self._call(
-            "APP_RESOLVED",
-            "已解析应用",
-            self._tools.builder.app_resolve(
-                profile=profile,
-                app_key=app_key,
-                app_name=app_name,
-                package_tag_id=package_tag_id,
-            ),
-        )
-
-    def app_show(self, *, profile: str, app_key: str) -> dict:
-        return self._call("APP_SUMMARY_READY", "已读取应用摘要", self._tools.builder.app_read_summary(profile=profile, app_key=app_key))
-
-    def fields_show(self, *, profile: str, app_key: str) -> dict:
-        return self._call("FIELDS_READY", "已读取字段摘要", self._tools.builder.app_read_fields(profile=profile, app_key=app_key))
-
-    def layout_show(self, *, profile: str, app_key: str) -> dict:
-        return self._call("LAYOUT_READY", "已读取布局摘要", self._tools.builder.app_read_layout_summary(profile=profile, app_key=app_key))
-
-    def views_show(self, *, profile: str, app_key: str) -> dict:
-        return self._call("VIEWS_READY", "已读取视图摘要", self._tools.builder.app_read_views_summary(profile=profile, app_key=app_key))
-
-    def flow_show(self, *, profile: str, app_key: str) -> dict:
-        return self._call("FLOW_READY", "已读取流程摘要", self._tools.builder.app_read_flow_summary(profile=profile, app_key=app_key))
-
-    def charts_show(self, *, profile: str, app_key: str) -> dict:
-        return self._call("CHARTS_READY", "已读取报表摘要", self._tools.builder.app_read_charts_summary(profile=profile, app_key=app_key))
-
-    def portal_show(self, *, profile: str, dash_key: str, being_draft: bool) -> dict:
-        return self._call(
-            "PORTAL_READY",
-            "已读取门户摘要",
-            self._tools.builder.portal_read_summary(profile=profile, dash_key=dash_key, being_draft=being_draft),
-        )
-
-    def fields_apply(
-        self,
-        *,
-        profile: str,
-        app_key: str,
-        package_tag_id: int | None,
-        app_name: str,
-        app_title: str,
-        create_if_missing: bool,
-        publish: bool,
-        add_fields: list[Any],
-        update_fields: list[Any],
-        remove_fields: list[Any],
-    ) -> dict:
-        return self._call(
-            "FIELDS_APPLIED",
-            "已执行字段变更",
-            self._tools.builder.app_schema_apply(
-                profile=profile,
-                app_key=app_key,
-                package_tag_id=package_tag_id,
-                app_name=app_name,
-                app_title=app_title,
-                create_if_missing=create_if_missing,
-                publish=publish,
-                add_fields=[_normalize_field_spec(item) for item in add_fields],
-                update_fields=[_normalize_field_update(item) for item in update_fields],
-                remove_fields=[_normalize_field_selector(item) for item in remove_fields],
-            ),
-        )
-
-    def layout_apply(
-        self,
-        *,
-        profile: str,
-        app_key: str,
-        mode: str,
-        publish: bool,
-        sections: list[Any],
-    ) -> dict:
-        return self._call(
-            "LAYOUT_APPLIED",
-            "已执行布局变更",
-            self._tools.builder.app_layout_apply(
-                profile=profile,
-                app_key=app_key,
-                mode=mode,
-                publish=publish,
-                sections=sections,
-            ),
-        )
-
-    def flow_apply(
-        self,
-        *,
-        profile: str,
-        app_key: str,
-        mode: str,
-        publish: bool,
-        nodes: list[Any],
-        transitions: list[Any],
-    ) -> dict:
-        return self._call(
-            "FLOW_APPLIED",
-            "已执行流程变更",
-            self._tools.builder.app_flow_apply(
-                profile=profile,
-                app_key=app_key,
-                mode=mode,
-                publish=publish,
-                nodes=nodes,
-                transitions=transitions,
-            ),
-        )
-
-    def views_apply(
-        self,
-        *,
-        profile: str,
-        app_key: str,
-        publish: bool,
-        upsert_views: list[Any],
-        remove_views: list[Any],
-    ) -> dict:
-        return self._call(
-            "VIEWS_APPLIED",
-            "已执行视图变更",
-            self._tools.builder.app_views_apply(
-                profile=profile,
-                app_key=app_key,
-                publish=publish,
-                upsert_views=upsert_views,
-                remove_views=remove_views,
-            ),
-        )
-
-    def charts_apply(
-        self,
-        *,
-        profile: str,
-        app_key: str,
-        upsert_charts: list[Any],
-        remove_chart_ids: list[Any],
-        reorder_chart_ids: list[Any],
-    ) -> dict:
-        return self._call(
-            "CHARTS_APPLIED",
-            "已执行报表变更",
-            self._tools.builder.app_charts_apply(
-                profile=profile,
-                app_key=app_key,
-                upsert_charts=upsert_charts,
-                remove_chart_ids=remove_chart_ids,
-                reorder_chart_ids=reorder_chart_ids,
-            ),
-        )
-
-    def portal_apply(
-        self,
-        *,
-        profile: str,
-        dash_key: str,
-        dash_name: str,
-        package_tag_id: int | None,
-        publish: bool,
-        sections: list[Any],
-        auth: dict | None,
-        icon: str | None,
-        color: str | None,
-        hide_copyright: bool | None,
-        dash_global_config: dict | None,
-        config: dict | None,
-    ) -> dict:
-        return self._call(
-            "PORTAL_APPLIED",
-            "已执行门户变更",
-            self._tools.builder.portal_apply(
-                profile=profile,
-                dash_key=dash_key,
-                dash_name=dash_name,
-                package_tag_id=package_tag_id,
-                publish=publish,
-                sections=sections,
-                auth=auth,
-                icon=icon,
-                color=color,
-                hide_copyright=hide_copyright,
-                dash_global_config=dash_global_config,
-                config=config,
-            ),
-        )
-
-    def publish_verify(self, *, profile: str, app_key: str, expected_package_tag_id: int | None) -> dict:
-        return self._call(
-            "PUBLISH_VERIFIED",
-            "已完成发布校验",
-            self._tools.builder.app_publish_verify(
-                profile=profile,
-                app_key=app_key,
-                expected_package_tag_id=expected_package_tag_id,
-            ),
-        )
-
-    def _call(self, code: str, message: str, raw: Any) -> dict:
-        if isinstance(raw, dict) and (raw.get("ok") is False or str(raw.get("status") or "").lower() in {"failed", "blocked"}):
-            return normalize_tool_error(raw)
-        warnings = raw.get("warnings") if isinstance(raw, dict) and isinstance(raw.get("warnings"), list) else []
-        meta = {}
-        if isinstance(raw, dict):
-            if raw.get("profile") is not None:
-                meta["profile"] = raw.get("profile")
-            if raw.get("request_id") is not None:
-                meta["request_id"] = raw.get("request_id")
-            if raw.get("request_route") is not None:
-                meta["request_route"] = raw.get("request_route")
-            if raw.get("verification") not in (None, {}):
-                meta["verification"] = raw.get("verification")
-        data = tool_payload(raw)
-        if isinstance(data, dict):
-            normalized_args = data.pop("normalized_args", None)
-            verified = data.pop("verified", None)
-            if normalized_args is not None:
-                meta["normalized_args"] = normalized_args
-            if verified is not None:
-                meta["verified"] = verified
-        return success_result(code, message, data=data, warnings=warnings, meta=meta, legacy=raw)
-
-
-def _normalize_field_spec(value: Any) -> Any:
-    if not isinstance(value, dict):
-        return value
-    normalized = dict(value)
-    if "name" not in normalized and isinstance(normalized.get("field_name"), str):
-        normalized["name"] = normalized["field_name"]
-    if "type" not in normalized and isinstance(normalized.get("field_type"), str):
-        normalized["type"] = normalized["field_type"]
-    normalized.pop("field_name", None)
-    normalized.pop("field_type", None)
-    return normalized
-
-
-def _normalize_field_selector(value: Any) -> Any:
-    if not isinstance(value, dict):
-        return value
-    normalized = dict(value)
-    if "name" not in normalized and isinstance(normalized.get("field_name"), str):
-        normalized["name"] = normalized["field_name"]
-    normalized.pop("field_name", None)
-    return normalized
-
-
-def _normalize_field_update(value: Any) -> Any:
-    if not isinstance(value, dict):
-        return value
-    normalized = dict(value)
-    if isinstance(normalized.get("selector"), dict):
-        normalized["selector"] = _normalize_field_selector(normalized["selector"])
-    if isinstance(normalized.get("set"), dict):
-        normalized["set"] = _normalize_field_spec(normalized["set"])
-    return normalized