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

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

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,
-        )