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

package/src/qingflow_mcp/ops/context.py

@@ -1,120 +0,0 @@
-from __future__ import annotations
-
-from dataclasses import dataclass
-
-from ..backend_client import BackendClient
-from ..builder_facade.service import AiBuilderFacade
-from ..session_store import SessionStore
-from ..tools.ai_builder_tools import AiBuilderTools
-from ..tools.app_tools import AppTools
-from ..tools.auth_tools import AuthTools
-from ..tools.code_block_tools import CodeBlockTools
-from ..tools.directory_tools import DirectoryTools
-from ..tools.feedback_tools import FeedbackTools
-from ..tools.file_tools import FileTools
-from ..tools.import_tools import ImportTools
-from ..tools.package_tools import PackageTools
-from ..tools.portal_tools import PortalTools
-from ..tools.qingbi_report_tools import QingbiReportTools
-from ..tools.record_tools import RecordTools
-from ..tools.role_tools import RoleTools
-from ..tools.solution_tools import SolutionTools
-from ..tools.task_context_tools import TaskContextTools
-from ..tools.view_tools import ViewTools
-from ..tools.workflow_tools import WorkflowTools
-from ..tools.workspace_tools import WorkspaceTools
-from .apps import AppOperations
-from .auth import AuthOperations
-from .builder import BuilderOperations
-from .directory import DirectoryOperations
-from .feedback import FeedbackOperations
-from .files import FileOperations
-from .imports import ImportOperations
-from .records import RecordOperations
-from .tasks import TaskOperations
-from .workspace import WorkspaceOperations
-
-
-@dataclass(slots=True)
-class Toolset:
-    auth: AuthTools
-    workspace: WorkspaceTools
-    app: AppTools
-    file: FileTools
-    feedback: FeedbackTools
-    directory: DirectoryTools
-    record: RecordTools
-    code_block: CodeBlockTools
-    imports: ImportTools
-    task: TaskContextTools
-    builder: AiBuilderTools
-    facade: AiBuilderFacade
-
-
-@dataclass(slots=True)
-class OperationsRuntime:
-    sessions: SessionStore
-    backend: BackendClient
-    tools: Toolset
-    auth: AuthOperations
-    workspace: WorkspaceOperations
-    apps: AppOperations
-    files: FileOperations
-    feedback: FeedbackOperations
-    directory: DirectoryOperations
-    records: RecordOperations
-    imports: ImportOperations
-    tasks: TaskOperations
-    builder: BuilderOperations
-
-    def close(self) -> None:
-        self.backend.close()
-
-def build_operations_runtime(
-    *,
-    sessions: SessionStore | None = None,
-    backend: BackendClient | None = None,
-    feedback_mcp_side: str = "CLI",
-) -> OperationsRuntime:
-    sessions = sessions or SessionStore()
-    backend = backend or BackendClient()
-    facade = AiBuilderFacade(
-        apps=AppTools(sessions, backend),
-        packages=PackageTools(sessions, backend),
-        views=ViewTools(sessions, backend),
-        workflows=WorkflowTools(sessions, backend),
-        portals=PortalTools(sessions, backend),
-        charts=QingbiReportTools(sessions, backend),
-        roles=RoleTools(sessions, backend),
-        directory=DirectoryTools(sessions, backend),
-        solutions=SolutionTools(sessions, backend),
-    )
-    tools = Toolset(
-        auth=AuthTools(sessions, backend),
-        workspace=WorkspaceTools(sessions, backend),
-        app=AppTools(sessions, backend),
-        file=FileTools(sessions, backend),
-        feedback=FeedbackTools(backend, mcp_side=feedback_mcp_side),
-        directory=DirectoryTools(sessions, backend),
-        record=RecordTools(sessions, backend),
-        code_block=CodeBlockTools(sessions, backend),
-        imports=ImportTools(sessions, backend),
-        task=TaskContextTools(sessions, backend),
-        builder=AiBuilderTools(sessions, backend),
-        facade=facade,
-    )
-    return OperationsRuntime(
-        sessions=sessions,
-        backend=backend,
-        tools=tools,
-        auth=AuthOperations(tools),
-        workspace=WorkspaceOperations(tools),
-        apps=AppOperations(tools),
-        files=FileOperations(tools),
-        feedback=FeedbackOperations(tools),
-        directory=DirectoryOperations(tools),
-        records=RecordOperations(tools),
-        imports=ImportOperations(tools),
-        tasks=TaskOperations(tools),
-        builder=BuilderOperations(tools),
-    )

package/src/qingflow_mcp/ops/directory.py

@@ -1,171 +0,0 @@
-from __future__ import annotations
-
-from typing import Any
-
-from .base import normalize_exception, success_result, tool_payload
-
-
-class DirectoryOperations:
-    def __init__(self, tools: Any) -> None:
-        self._tools = tools
-
-    def search(
-        self,
-        *,
-        profile: str,
-        query: str,
-        scopes: list[str] | None,
-        page_num: int,
-        page_size: int,
-    ) -> dict:
-        return self._call(
-            "DIRECTORY_SEARCH_READY",
-            "已完成目录搜索",
-            profile=profile,
-            raw_call=lambda: self._tools.directory.directory_search(
-                profile=profile,
-                query=query,
-                scopes=scopes,
-                page_num=page_num,
-                page_size=page_size,
-            ),
-        )
-
-    def list_internal_users(
-        self,
-        *,
-        profile: str,
-        keyword: str | None,
-        department_id: int | None,
-        role_id: int | None,
-        page_num: int,
-        page_size: int,
-        include_disabled: bool,
-    ) -> dict:
-        return self._call(
-            "DIRECTORY_INTERNAL_USERS_READY",
-            "已读取内部成员",
-            profile=profile,
-            raw_call=lambda: self._tools.directory.directory_list_internal_users(
-                profile=profile,
-                keyword=keyword,
-                dept_id=department_id,
-                role_id=role_id,
-                page_num=page_num,
-                page_size=page_size,
-                contain_disable=include_disabled,
-            ),
-        )
-
-    def list_all_internal_users(
-        self,
-        *,
-        profile: str,
-        keyword: str | None,
-        department_id: int | None,
-        role_id: int | None,
-        page_size: int,
-        include_disabled: bool,
-        max_pages: int,
-    ) -> dict:
-        return self._call(
-            "DIRECTORY_ALL_INTERNAL_USERS_READY",
-            "已读取全部内部成员",
-            profile=profile,
-            raw_call=lambda: self._tools.directory.directory_list_all_internal_users(
-                profile=profile,
-                keyword=keyword,
-                dept_id=department_id,
-                role_id=role_id,
-                page_size=page_size,
-                contain_disable=include_disabled,
-                max_pages=max_pages,
-            ),
-        )
-
-    def list_internal_departments(
-        self,
-        *,
-        profile: str,
-        keyword: str,
-        page_num: int,
-        page_size: int,
-    ) -> dict:
-        return self._call(
-            "DIRECTORY_INTERNAL_DEPARTMENTS_READY",
-            "已读取内部部门",
-            profile=profile,
-            raw_call=lambda: self._tools.directory.directory_list_internal_departments(
-                profile=profile,
-                keyword=keyword,
-                page_num=page_num,
-                page_size=page_size,
-            ),
-        )
-
-    def list_all_departments(
-        self,
-        *,
-        profile: str,
-        parent_department_id: int | None,
-        max_depth: int,
-        max_items: int,
-    ) -> dict:
-        return self._call(
-            "DIRECTORY_ALL_DEPARTMENTS_READY",
-            "已读取全部部门",
-            profile=profile,
-            raw_call=lambda: self._tools.directory.directory_list_all_departments(
-                profile=profile,
-                parent_dept_id=parent_department_id,
-                max_depth=max_depth,
-                max_items=max_items,
-            ),
-        )
-
-    def list_sub_departments(self, *, profile: str, parent_department_id: int | None) -> dict:
-        return self._call(
-            "DIRECTORY_SUB_DEPARTMENTS_READY",
-            "已读取子部门",
-            profile=profile,
-            raw_call=lambda: self._tools.directory.directory_list_sub_departments(
-                profile=profile,
-                parent_dept_id=parent_department_id,
-            ),
-        )
-
-    def list_external_members(
-        self,
-        *,
-        profile: str,
-        keyword: str | None,
-        page_num: int,
-        page_size: int,
-        simple: bool,
-    ) -> dict:
-        return self._call(
-            "DIRECTORY_EXTERNAL_MEMBERS_READY",
-            "已读取外部联系人",
-            profile=profile,
-            raw_call=lambda: self._tools.directory.directory_list_external_members(
-                profile=profile,
-                keyword=keyword,
-                page_num=page_num,
-                page_size=page_size,
-                simple=simple,
-            ),
-        )
-
-    def _call(self, code: str, message: str, *, profile: str, raw_call: Any) -> dict:
-        try:
-            raw = raw_call()
-        except Exception as error:  # noqa: BLE001
-            return normalize_exception(error)
-        return success_result(
-            code,
-            message,
-            data=tool_payload(raw) if isinstance(tool_payload(raw), dict) else raw,
-            warnings=raw.get("warnings") if isinstance(raw, dict) and isinstance(raw.get("warnings"), list) else [],
-            meta={"profile": profile, "request_route": raw.get("request_route") if isinstance(raw, dict) else None},
-            legacy=raw,
-        )

package/src/qingflow_mcp/ops/feedback.py

@@ -1,49 +0,0 @@
-from __future__ import annotations
-
-from typing import Any
-
-from .base import normalize_exception, success_result, tool_payload
-
-
-class FeedbackOperations:
-    def __init__(self, tools: Any) -> None:
-        self._tools = tools
-
-    def submit(
-        self,
-        *,
-        category: str,
-        title: str,
-        description: str,
-        expected_behavior: str | None,
-        actual_behavior: str | None,
-        impact_scope: str | None,
-        tool_name: str | None,
-        app_key: str | None,
-        record_id: str | int | None,
-        workflow_node_id: str | int | None,
-        note: str | None,
-    ) -> dict:
-        try:
-            raw = self._tools.feedback.feedback_submit(
-                category=category,
-                title=title,
-                description=description,
-                expected_behavior=expected_behavior,
-                actual_behavior=actual_behavior,
-                impact_scope=impact_scope,
-                tool_name=tool_name,
-                app_key=app_key,
-                record_id=record_id,
-                workflow_node_id=workflow_node_id,
-                note=note,
-            )
-        except Exception as error:  # noqa: BLE001
-            return normalize_exception(error)
-        return success_result(
-            "FEEDBACK_SUBMITTED",
-            "已提交需求反馈",
-            data=tool_payload(raw) if isinstance(tool_payload(raw), dict) else raw,
-            meta={"request_route": raw.get("request_route") if isinstance(raw, dict) else None},
-            legacy=raw,
-        )

package/src/qingflow_mcp/ops/files.py

@@ -1,78 +0,0 @@
-from __future__ import annotations
-
-from typing import Any
-
-from .base import normalize_exception, success_result, tool_payload
-
-
-class FileOperations:
-    def __init__(self, tools: Any) -> None:
-        self._tools = tools
-
-    def get_upload_info(
-        self,
-        *,
-        profile: str,
-        upload_kind: str,
-        file_name: str,
-        file_size: int,
-        upload_mark: str | None,
-        content_type: str | None,
-        bucket_type: str | None,
-        path_id: int | None,
-        file_related_url: str | None,
-    ) -> dict:
-        try:
-            raw = self._tools.file.file_get_upload_info(
-                profile=profile,
-                upload_kind=upload_kind,
-                file_name=file_name,
-                file_size=file_size,
-                upload_mark=upload_mark,
-                content_type=content_type,
-                bucket_type=bucket_type,
-                path_id=path_id,
-                file_related_url=file_related_url,
-            )
-        except Exception as error:  # noqa: BLE001
-            return normalize_exception(error)
-        return success_result(
-            "UPLOAD_INFO_READY",
-            "已获取上传信息",
-            data=tool_payload(raw) if isinstance(tool_payload(raw), dict) else raw,
-            meta={"profile": profile, "request_route": raw.get("request_route") if isinstance(raw, dict) else None},
-            legacy=raw,
-        )
-
-    def upload_local(
-        self,
-        *,
-        profile: str,
-        upload_kind: str,
-        file_path: str,
-        upload_mark: str | None,
-        content_type: str | None,
-        bucket_type: str | None,
-        path_id: int | None,
-        file_related_url: str | None,
-    ) -> dict:
-        try:
-            raw = self._tools.file.file_upload_local(
-                profile=profile,
-                upload_kind=upload_kind,
-                file_path=file_path,
-                upload_mark=upload_mark,
-                content_type=content_type,
-                bucket_type=bucket_type,
-                path_id=path_id,
-                file_related_url=file_related_url,
-            )
-        except Exception as error:  # noqa: BLE001
-            return normalize_exception(error)
-        return success_result(
-            "FILE_UPLOADED",
-            "已完成本地文件上传",
-            data=tool_payload(raw) if isinstance(tool_payload(raw), dict) else raw,
-            meta={"profile": profile, "request_route": raw.get("request_route") if isinstance(raw, dict) else None},
-            legacy=raw,
-        )

package/src/qingflow_mcp/ops/imports.py

@@ -1,140 +0,0 @@
-from __future__ import annotations
-
-from typing import Any
-
-from .base import normalize_exception, success_result, tool_payload
-
-
-class ImportOperations:
-    def __init__(self, tools: Any) -> None:
-        self._tools = tools
-
-    def schema(self, *, profile: str, app_key: str, output_profile: str = "normal") -> dict:
-        try:
-            raw = self._tools.imports.record_import_schema_get(
-                profile=profile,
-                app_key=app_key,
-                output_profile=output_profile,
-            )
-        except Exception as error:  # noqa: BLE001
-            return normalize_exception(error)
-        return success_result(
-            "IMPORT_SCHEMA_READY",
-            "已读取导入字段结构",
-            data=tool_payload(raw) if isinstance(tool_payload(raw), dict) else raw,
-            warnings=raw.get("warnings") if isinstance(raw, dict) and isinstance(raw.get("warnings"), list) else [],
-            meta={"profile": profile},
-            legacy=raw,
-        )
-
-    def template(self, *, profile: str, app_key: str, download_to_path: str | None) -> dict:
-        try:
-            raw = self._tools.imports.record_import_template_get(
-                profile=profile,
-                app_key=app_key,
-                download_to_path=download_to_path,
-            )
-        except Exception as error:  # noqa: BLE001
-            return normalize_exception(error)
-        return success_result(
-            "IMPORT_TEMPLATE_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 verify(self, *, profile: str, app_key: str, file_path: str) -> dict:
-        try:
-            raw = self._tools.imports.record_import_verify(profile=profile, app_key=app_key, file_path=file_path)
-        except Exception as error:  # noqa: BLE001
-            return normalize_exception(error)
-        return success_result(
-            "IMPORT_VERIFIED",
-            "已完成导入预检",
-            data=tool_payload(raw) if isinstance(tool_payload(raw), dict) else 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 repair(
-        self,
-        *,
-        profile: str,
-        verification_id: str,
-        authorized_file_modification: bool,
-        output_path: str | None,
-        selected_repairs: list[str],
-    ) -> dict:
-        try:
-            raw = self._tools.imports.record_import_repair_local(
-                profile=profile,
-                verification_id=verification_id,
-                authorized_file_modification=authorized_file_modification,
-                output_path=output_path,
-                selected_repairs=selected_repairs,
-            )
-        except Exception as error:  # noqa: BLE001
-            return normalize_exception(error)
-        return success_result(
-            "IMPORT_FILE_REPAIRED",
-            "已完成导入文件修复",
-            data=tool_payload(raw) if isinstance(tool_payload(raw), dict) else raw,
-            warnings=raw.get("warnings") if isinstance(raw, dict) and isinstance(raw.get("warnings"), list) else [],
-            meta={"profile": profile},
-            legacy=raw,
-        )
-
-    def start(
-        self,
-        *,
-        profile: str,
-        app_key: str,
-        verification_id: str,
-        being_enter_auditing: bool | None,
-        view_key: str | None,
-    ) -> dict:
-        try:
-            raw = self._tools.imports.record_import_start(
-                profile=profile,
-                app_key=app_key,
-                verification_id=verification_id,
-                being_enter_auditing=being_enter_auditing,
-                view_key=view_key,
-            )
-        except Exception as error:  # noqa: BLE001
-            return normalize_exception(error)
-        return success_result(
-            "IMPORT_STARTED",
-            "已启动导入任务",
-            data=tool_payload(raw) if isinstance(tool_payload(raw), dict) else 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 status(self, *, profile: str, app_key: str, import_id: str | None, process_id_str: str | None) -> dict:
-        try:
-            raw = self._tools.imports.record_import_status_get(
-                profile=profile,
-                app_key=app_key,
-                import_id=import_id,
-                process_id_str=process_id_str,
-            )
-        except Exception as error:  # noqa: BLE001
-            return normalize_exception(error)
-        data = tool_payload(raw) if isinstance(tool_payload(raw), dict) else raw
-        if isinstance(data, dict) and raw.get("status") is not None:
-            data = dict(data)
-            data["status"] = raw.get("status")
-            data["raw_status"] = raw.get("status")
-        return success_result(
-            "IMPORT_STATUS_READY",
-            "已读取导入状态",
-            data=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,
-        )