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

package/src/qingflow_mcp/ops/records.py

@@ -1,415 +0,0 @@
-from __future__ import annotations
-
-from typing import Any
-
-from .base import normalize_exception, success_result, tool_payload
-
-
-class RecordOperations:
-    def __init__(self, tools: Any) -> None:
-        self._tools = tools
-
-    def schema(
-        self,
-        *,
-        profile: str,
-        app_key: str,
-        mode: str,
-        view_id: str | None,
-        record_id: int | None,
-        output_profile: str = "normal",
-    ) -> dict:
-        try:
-            if mode == "applicant":
-                raw = self._tools.record.record_schema_get(
-                    profile=profile,
-                    app_key=app_key,
-                    schema_mode="applicant",
-                    output_profile=output_profile,
-                )
-            elif mode == "browse":
-                raw = self._tools.record.record_browse_schema_get_public(
-                    profile=profile,
-                    app_key=app_key,
-                    view_id=view_id,
-                    output_profile=output_profile,
-                )
-            elif mode == "insert":
-                raw = self._tools.record.record_insert_schema_get_public(
-                    profile=profile,
-                    app_key=app_key,
-                    output_profile=output_profile,
-                )
-            elif mode == "update":
-                raw = self._tools.record.record_update_schema_get_public(
-                    profile=profile,
-                    app_key=app_key,
-                    record_id=record_id,
-                    output_profile=output_profile,
-                )
-            elif mode == "import":
-                raw = self._tools.imports.record_import_schema_get(
-                    profile=profile,
-                    app_key=app_key,
-                    output_profile=output_profile,
-                )
-            else:
-                raw = self._tools.code_block.record_code_block_schema_get_public(
-                    profile=profile,
-                    app_key=app_key,
-                    output_profile=output_profile,
-                )
-        except Exception as error:  # noqa: BLE001
-            return normalize_exception(error)
-        return success_result(
-            "RECORD_SCHEMA_READY",
-            "已读取表结构",
-            data={"mode": mode, "schema": tool_payload(raw)},
-            warnings=raw.get("warnings") if isinstance(raw, dict) and isinstance(raw.get("warnings"), list) else [],
-            meta={"profile": profile},
-            legacy=raw,
-        )
-
-    def list(
-        self,
-        *,
-        profile: str,
-        app_key: str,
-        columns: list[Any],
-        where: list[Any],
-        order_by: list[Any],
-        limit: int,
-        page: int,
-        view_id: str | None,
-        list_type: int | None,
-        view_key: str | None,
-        view_name: str | None,
-        output_profile: str = "normal",
-    ) -> dict:
-        try:
-            raw = self._tools.record.record_list(
-                profile=profile,
-                app_key=app_key,
-                columns=columns,
-                where=where,
-                order_by=order_by,
-                limit=limit,
-                page=page,
-                view_id=view_id,
-                list_type=list_type,
-                view_key=view_key,
-                view_name=view_name,
-                output_profile=output_profile,
-            )
-        except Exception as error:  # noqa: BLE001
-            return normalize_exception(error)
-        data = tool_payload(raw)
-        return success_result(
-            "RECORDS_LISTED",
-            "已读取记录列表",
-            data=data if isinstance(data, dict) else {"items": data},
-            warnings=raw.get("warnings") if isinstance(raw, dict) and isinstance(raw.get("warnings"), list) else [],
-            meta={"profile": profile},
-            legacy=raw,
-        )
-
-    def get(
-        self,
-        *,
-        profile: str,
-        app_key: str,
-        record_id: int,
-        columns: list[Any],
-        view_id: str | None,
-        workflow_node_id: int | None,
-        output_profile: str = "normal",
-    ) -> dict:
-        try:
-            raw = self._tools.record.record_get_public(
-                profile=profile,
-                app_key=app_key,
-                record_id=record_id,
-                columns=columns,
-                view_id=view_id,
-                workflow_node_id=workflow_node_id,
-                output_profile=output_profile,
-            )
-        except Exception as error:  # noqa: BLE001
-            return normalize_exception(error)
-        return success_result(
-            "RECORD_SHOWN",
-            "已读取单条记录",
-            data={"record": tool_payload(raw), "record_id": record_id},
-            warnings=raw.get("warnings") if isinstance(raw, dict) and isinstance(raw.get("warnings"), list) else [],
-            meta={"profile": profile},
-            legacy=raw,
-        )
-
-    def create(
-        self,
-        *,
-        profile: str,
-        app_key: str,
-        fields: dict[str, Any],
-        verify_write: bool,
-        output_profile: str = "normal",
-    ) -> dict:
-        try:
-            raw = self._tools.record.record_insert_public(
-                profile=profile,
-                app_key=app_key,
-                fields=fields,
-                verify_write=verify_write,
-                output_profile=output_profile,
-            )
-        except Exception as error:  # noqa: BLE001
-            return normalize_exception(error)
-        data = tool_payload(raw)
-        return success_result(
-            "RECORD_CREATED",
-            "已新增记录",
-            data={
-                "record_id": _extract_record_id(data),
-                "record_ids": _extract_record_ids(data),
-                "result": data,
-            },
-            warnings=raw.get("warnings") if isinstance(raw, dict) and isinstance(raw.get("warnings"), list) else [],
-            meta={"profile": profile, "verification": raw.get("verification") if isinstance(raw, dict) else None},
-            legacy=raw,
-        )
-
-    def update(
-        self,
-        *,
-        profile: str,
-        app_key: str,
-        record_id: int | None,
-        fields: dict[str, Any],
-        verify_write: bool,
-        output_profile: str = "normal",
-    ) -> dict:
-        try:
-            raw = self._tools.record.record_update_public(
-                profile=profile,
-                app_key=app_key,
-                record_id=record_id,
-                fields=fields,
-                verify_write=verify_write,
-                output_profile=output_profile,
-            )
-        except Exception as error:  # noqa: BLE001
-            return normalize_exception(error)
-        data = tool_payload(raw)
-        return success_result(
-            "RECORD_UPDATED",
-            "已更新记录",
-            data={
-                "record_id": _extract_record_id(data) or record_id,
-                "record_ids": _extract_record_ids(data) or [record_id],
-                "result": data,
-            },
-            warnings=raw.get("warnings") if isinstance(raw, dict) and isinstance(raw.get("warnings"), list) else [],
-            meta={"profile": profile, "verification": raw.get("verification") if isinstance(raw, dict) else None},
-            legacy=raw,
-        )
-
-    def delete(
-        self,
-        *,
-        profile: str,
-        app_key: str,
-        record_id: int | None,
-        record_ids: list[int],
-        output_profile: str = "normal",
-    ) -> dict:
-        try:
-            raw = self._tools.record.record_delete_public(
-                profile=profile,
-                app_key=app_key,
-                record_id=record_id,
-                record_ids=record_ids,
-                output_profile=output_profile,
-            )
-        except Exception as error:  # noqa: BLE001
-            return normalize_exception(error)
-        data = tool_payload(raw)
-        removed = _extract_record_ids(data) or ([record_id] if record_id else record_ids)
-        return success_result(
-            "RECORDS_DELETED",
-            "已删除记录",
-            data={"record_ids": removed, "result": data},
-            warnings=raw.get("warnings") if isinstance(raw, dict) and isinstance(raw.get("warnings"), list) else [],
-            meta={"profile": profile, "verification": raw.get("verification") if isinstance(raw, dict) else None},
-            legacy=raw,
-        )
-
-    def analyze(
-        self,
-        *,
-        profile: str,
-        app_key: str,
-        dimensions: list[Any],
-        metrics: list[Any],
-        filters: list[Any],
-        sort: list[Any],
-        limit: int,
-        strict_full: bool,
-        view_id: str | None,
-        list_type: int | None,
-        view_key: str | None,
-        view_name: str | None,
-        output_profile: str = "normal",
-    ) -> dict:
-        try:
-            raw = self._tools.record.record_analyze(
-                profile=profile,
-                app_key=app_key,
-                dimensions=dimensions,
-                metrics=metrics,
-                filters=filters,
-                sort=sort,
-                limit=limit,
-                strict_full=strict_full,
-                view_id=view_id,
-                list_type=list_type,
-                view_key=view_key,
-                view_name=view_name,
-                output_profile=output_profile,
-            )
-        except Exception as error:  # noqa: BLE001
-            return normalize_exception(error)
-        return success_result(
-            "RECORDS_ANALYZED",
-            "已完成数据分析",
-            data=tool_payload(raw),
-            warnings=raw.get("warnings") if isinstance(raw, dict) and isinstance(raw.get("warnings"), list) else [],
-            meta={"profile": profile},
-            legacy=raw,
-        )
-
-    def run_code(
-        self,
-        *,
-        profile: str,
-        app_key: str,
-        record_id: int,
-        code_block_field: str,
-        role: int,
-        workflow_node_id: int | None,
-        answers: list[Any],
-        fields: dict[str, Any],
-        manual: bool,
-        verify_writeback: bool,
-        force_refresh_form: bool,
-        output_profile: str = "normal",
-    ) -> dict:
-        try:
-            raw = self._tools.code_block.record_code_block_run(
-                profile=profile,
-                app_key=app_key,
-                record_id=record_id,
-                code_block_field=code_block_field,
-                role=role,
-                workflow_node_id=workflow_node_id,
-                answers=answers,
-                fields=fields,
-                manual=manual,
-                verify_writeback=verify_writeback,
-                force_refresh_form=force_refresh_form,
-                output_profile=output_profile,
-            )
-        except Exception as error:  # noqa: BLE001
-            return normalize_exception(error)
-        return success_result(
-            "CODE_BLOCK_EXECUTED",
-            "已执行代码块字段",
-            data=tool_payload(raw),
-            warnings=raw.get("warnings") if isinstance(raw, dict) and isinstance(raw.get("warnings"), list) else [],
-            meta={"profile": profile, "verification": raw.get("verification") if isinstance(raw, dict) else None},
-            legacy=raw,
-        )
-
-    def member_candidates(
-        self,
-        *,
-        profile: str,
-        app_key: str,
-        field_id: int,
-        keyword: str,
-        page_num: int,
-        page_size: int,
-    ) -> dict:
-        try:
-            raw = self._tools.record.record_member_candidates(
-                profile=profile,
-                app_key=app_key,
-                field_id=field_id,
-                keyword=keyword,
-                page_num=page_num,
-                page_size=page_size,
-            )
-        except Exception as error:  # noqa: BLE001
-            return normalize_exception(error)
-        return success_result(
-            "RECORD_MEMBER_CANDIDATES_READY",
-            "已读取成员候选范围",
-            data=tool_payload(raw),
-            warnings=raw.get("warnings") if isinstance(raw, dict) and isinstance(raw.get("warnings"), list) else [],
-            meta={"profile": profile},
-            legacy=raw,
-        )
-
-    def department_candidates(
-        self,
-        *,
-        profile: str,
-        app_key: str,
-        field_id: int,
-        keyword: str,
-        page_num: int,
-        page_size: int,
-    ) -> dict:
-        try:
-            raw = self._tools.record.record_department_candidates(
-                profile=profile,
-                app_key=app_key,
-                field_id=field_id,
-                keyword=keyword,
-                page_num=page_num,
-                page_size=page_size,
-            )
-        except Exception as error:  # noqa: BLE001
-            return normalize_exception(error)
-        return success_result(
-            "RECORD_DEPARTMENT_CANDIDATES_READY",
-            "已读取部门候选范围",
-            data=tool_payload(raw),
-            warnings=raw.get("warnings") if isinstance(raw, dict) and isinstance(raw.get("warnings"), list) else [],
-            meta={"profile": profile},
-            legacy=raw,
-        )
-
-
-def _extract_record_id(data: Any) -> int | None:
-    if not isinstance(data, dict):
-        return None
-    value = data.get("record_id")
-    if isinstance(value, int):
-        return value
-    resource = data.get("resource")
-    if isinstance(resource, dict) and isinstance(resource.get("record_id"), int):
-        return resource.get("record_id")
-    return None
-
-
-def _extract_record_ids(data: Any) -> list[int]:
-    if not isinstance(data, dict):
-        return []
-    value = data.get("record_ids")
-    if isinstance(value, list):
-        return [item for item in value if isinstance(item, int)]
-    resource = data.get("resource")
-    if isinstance(resource, dict) and isinstance(resource.get("record_ids"), list):
-        return [item for item in resource["record_ids"] if isinstance(item, int)]
-    record_id = _extract_record_id(data)
-    return [record_id] if record_id is not None else []

package/src/qingflow_mcp/ops/tasks.py

@@ -1,171 +0,0 @@
-from __future__ import annotations
-
-from typing import Any
-
-from .base import normalize_exception, success_result, tool_payload
-
-
-class TaskOperations:
-    def __init__(self, tools: Any) -> None:
-        self._tools = tools
-
-    def list(
-        self,
-        *,
-        profile: str,
-        task_box: str,
-        flow_status: str,
-        app_key: str | None,
-        workflow_node_id: int | None,
-        query: str | None,
-        page: int,
-        page_size: int,
-    ) -> dict:
-        try:
-            raw = self._tools.task.task_list(
-                profile=profile,
-                task_box=task_box,
-                flow_status=flow_status,
-                app_key=app_key,
-                workflow_node_id=workflow_node_id,
-                query=query,
-                page=page,
-                page_size=page_size,
-            )
-        except Exception as error:  # noqa: BLE001
-            return normalize_exception(error)
-        data = tool_payload(raw)
-        if isinstance(data, dict) and isinstance(data.get("items"), list):
-            items = []
-            for item in data["items"]:
-                if not isinstance(item, dict):
-                    continue
-                title = item.get("title") or item.get("task_name") or item.get("node_name")
-                if not title:
-                    app_name = item.get("app_name") or item.get("app_key") or "任务"
-                    record_id = item.get("record_id")
-                    title = f"{app_name}#{record_id}" if record_id is not None else str(app_name)
-                normalized = dict(item)
-                normalized["title"] = title
-                items.append(normalized)
-            data = dict(data)
-            data["items"] = items
-        return success_result(
-            "TASKS_LISTED",
-            "已读取待办列表",
-            data=data if isinstance(data, dict) else {"items": data},
-            warnings=raw.get("warnings") if isinstance(raw, dict) and isinstance(raw.get("warnings"), list) else [],
-            meta={"profile": profile},
-            legacy=raw,
-        )
-
-    def show(
-        self,
-        *,
-        profile: str,
-        app_key: str,
-        record_id: int,
-        workflow_node_id: int,
-        include_candidates: bool,
-        include_associated_reports: bool,
-    ) -> dict:
-        try:
-            raw = self._tools.task.task_get(
-                profile=profile,
-                app_key=app_key,
-                record_id=record_id,
-                workflow_node_id=workflow_node_id,
-                include_candidates=include_candidates,
-                include_associated_reports=include_associated_reports,
-            )
-        except Exception as error:  # noqa: BLE001
-            return normalize_exception(error)
-        return success_result(
-            "TASK_READY",
-            "已读取待办详情",
-            data=tool_payload(raw),
-            warnings=raw.get("warnings") if isinstance(raw, dict) and isinstance(raw.get("warnings"), list) else [],
-            meta={"profile": profile},
-            legacy=raw,
-        )
-
-    def act(
-        self,
-        *,
-        profile: str,
-        app_key: str,
-        record_id: int,
-        workflow_node_id: int,
-        action: str,
-        payload: dict,
-    ) -> dict:
-        try:
-            raw = self._tools.task.task_action_execute(
-                profile=profile,
-                app_key=app_key,
-                record_id=record_id,
-                workflow_node_id=workflow_node_id,
-                action=action,
-                payload=payload,
-            )
-        except Exception as error:  # noqa: BLE001
-            return normalize_exception(error)
-        return success_result(
-            "TASK_ACTION_EXECUTED",
-            "已执行待办动作",
-            data=tool_payload(raw),
-            warnings=raw.get("warnings") if isinstance(raw, dict) and isinstance(raw.get("warnings"), list) else [],
-            meta={"profile": profile, "verification": raw.get("verification") if isinstance(raw, dict) else None},
-            legacy=raw,
-        )
-
-    def log(self, *, profile: str, app_key: str, record_id: int, workflow_node_id: int) -> dict:
-        try:
-            raw = self._tools.task.task_workflow_log_get(
-                profile=profile,
-                app_key=app_key,
-                record_id=record_id,
-                workflow_node_id=workflow_node_id,
-            )
-        except Exception as error:  # noqa: BLE001
-            return normalize_exception(error)
-        return success_result(
-            "TASK_LOG_READY",
-            "已读取流程日志",
-            data=tool_payload(raw),
-            warnings=raw.get("warnings") if isinstance(raw, dict) and isinstance(raw.get("warnings"), list) else [],
-            meta={"profile": profile},
-            legacy=raw,
-        )
-
-    def associated_report_detail(
-        self,
-        *,
-        profile: str,
-        app_key: str,
-        record_id: int,
-        workflow_node_id: int,
-        report_id: int,
-        page: int,
-        page_size: int,
-    ) -> dict:
-        try:
-            raw = self._tools.task.task_associated_report_detail_get(
-                profile=profile,
-                app_key=app_key,
-                record_id=record_id,
-                workflow_node_id=workflow_node_id,
-                report_id=report_id,
-                page=page,
-                page_size=page_size,
-            )
-        except Exception as error:  # noqa: BLE001
-            return normalize_exception(error)
-        return success_result(
-            "TASK_ASSOCIATED_REPORT_READY",
-            "已读取关联报表详情",
-            data=tool_payload(raw),
-            warnings=raw.get("warnings") if isinstance(raw, dict) and isinstance(raw.get("warnings"), list) else [],
-            meta={"profile": profile},
-            legacy=raw,
-        )

package/src/qingflow_mcp/ops/workspace.py

@@ -1,76 +0,0 @@
-from __future__ import annotations
-
-from typing import Any
-
-from .base import normalize_exception, success_result
-
-
-class WorkspaceOperations:
-    def __init__(self, tools: Any) -> None:
-        self._tools = tools
-
-    def list(
-        self,
-        *,
-        profile: str,
-        page_num: int,
-        page_size: int,
-        include_external: bool,
-    ) -> dict:
-        try:
-            raw = self._tools.workspace.workspace_list(
-                profile=profile,
-                page_num=page_num,
-                page_size=page_size,
-                include_external=include_external,
-            )
-        except Exception as error:  # noqa: BLE001
-            return normalize_exception(error)
-        page = raw.get("page") if isinstance(raw.get("page"), dict) else {}
-        items = page.get("list") if isinstance(page.get("list"), list) else []
-        normalized = [
-            {
-                "ws_id": item.get("wsId"),
-                "name": item.get("workspaceName") or item.get("wsName"),
-                "remark": item.get("remark"),
-                "system_version": item.get("systemVersion"),
-            }
-            for item in items
-            if isinstance(item, dict)
-        ]
-        return success_result(
-            "WORKSPACES_LISTED",
-            "已读取工作区列表",
-            data={
-                "items": normalized,
-                "page_num": page_num,
-                "page_size": page_size,
-                "include_external": include_external,
-                "total": page.get("total"),
-            },
-            meta={"profile": profile},
-            legacy=raw,
-        )
-
-    def use(self, *, profile: str, ws_id: int) -> dict:
-        try:
-            raw = self._tools.workspace.workspace_select(profile=profile, ws_id=ws_id)
-        except Exception as error:  # noqa: BLE001
-            return normalize_exception(error)
-        workspace = raw.get("workspace") if isinstance(raw.get("workspace"), dict) else {}
-        return success_result(
-            "WORKSPACE_SELECTED",
-            "已切换工作区",
-            data={
-                "workspace": {
-                    "ws_id": raw.get("selected_ws_id", ws_id),
-                    "name": raw.get("selected_ws_name"),
-                    "remark": workspace.get("remark"),
-                    "system_version": workspace.get("systemVersion"),
-                },
-                "qf_version": raw.get("qf_version"),
-                "qf_version_source": raw.get("qf_version_source"),
-            },
-            meta={"profile": profile, "request_route": raw.get("request_route")},
-            legacy=raw,
-        )