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

package/src/qingflow_mcp/cli/commands/imports.py

@@ -10,69 +10,77 @@ def register(subparsers: argparse._SubParsersAction[argparse.ArgumentParser]) ->
     parser = subparsers.add_parser("import", help="导入")
     import_subparsers = parser.add_subparsers(dest="import_command", required=True)
 
-    template = import_subparsers.add_parser("template", help="获取导入模板")
-    template.add_argument("--app", required=True)
-    template.add_argument("--to")
-    template.set_defaults(handler=_handle_template, format_hint="import_template")
+    template = import_subparsers.add_parser("template", help="下载导入模板")
+    template.add_argument("--app-key", required=True)
+    template.add_argument("--download-to-path")
+    template.set_defaults(handler=_handle_template, format_hint="")
 
     verify = import_subparsers.add_parser("verify", help="校验导入文件")
-    verify.add_argument("--app", required=True)
-    verify.add_argument("--file", required=True)
+    verify.add_argument("--app-key", required=True)
+    verify.add_argument("--file-path", required=True)
     verify.set_defaults(handler=_handle_verify, format_hint="import_verify")
 
-    repair = import_subparsers.add_parser("repair", help="在授权后修复导入文件")
-    repair.add_argument("--verification", required=True)
-    repair.add_argument("--authorize", action="store_true")
-    repair.add_argument("--to")
+    repair = import_subparsers.add_parser("repair", help="授权后修复导入文件")
+    repair.add_argument("--verification-id", required=True)
+    repair.add_argument("--authorized-file-modification", action="store_true")
+    repair.add_argument("--output-path")
     repair.add_argument("--repair", dest="selected_repairs", action="append", default=[])
-    repair.set_defaults(handler=_handle_repair, format_hint="import_repair")
+    repair.set_defaults(handler=_handle_repair, format_hint="")
 
     start = import_subparsers.add_parser("start", help="启动导入")
-    start.add_argument("--app", required=True)
-    start.add_argument("--verification", required=True)
-    start.add_argument("--enter-auditing", type=parse_bool_text, required=True)
-    start.add_argument("--view")
-    start.set_defaults(handler=_handle_start, format_hint="import_start")
-
-    status = import_subparsers.add_parser("status", help="查看导入状态")
-    status.add_argument("--app", required=True)
+    start.add_argument("--app-key", required=True)
+    start.add_argument("--verification-id", required=True)
+    start.add_argument("--being-enter-auditing", type=parse_bool_text, required=True)
+    start.add_argument("--view-key")
+    start.set_defaults(handler=_handle_start, format_hint="")
+
+    status = import_subparsers.add_parser("status", help="查询导入状态")
+    status.add_argument("--app-key", required=True)
     status.add_argument("--import-id")
-    status.add_argument("--process-id")
+    status.add_argument("--process-id-str")
     status.set_defaults(handler=_handle_status, format_hint="import_status")
 
 
 def _handle_template(args: argparse.Namespace, context: CliContext) -> dict:
-    return context.imports.template(profile=args.profile, app_key=args.app, download_to_path=args.to)
+    return context.imports.record_import_template_get(
+        profile=args.profile,
+        app_key=args.app_key,
+        download_to_path=args.download_to_path,
+    )
 
 
 def _handle_verify(args: argparse.Namespace, context: CliContext) -> dict:
-    return context.imports.verify(profile=args.profile, app_key=args.app, file_path=args.file)
+    return context.imports.record_import_verify(
+        profile=args.profile,
+        app_key=args.app_key,
+        file_path=args.file_path,
+    )
 
 
 def _handle_repair(args: argparse.Namespace, context: CliContext) -> dict:
-    return context.imports.repair(
+    return context.imports.record_import_repair_local(
         profile=args.profile,
-        verification_id=args.verification,
-        authorized_file_modification=bool(args.authorize),
-        output_path=args.to,
+        verification_id=args.verification_id,
+        authorized_file_modification=bool(args.authorized_file_modification),
+        output_path=args.output_path,
         selected_repairs=list(args.selected_repairs or []),
     )
 
 
 def _handle_start(args: argparse.Namespace, context: CliContext) -> dict:
-    return context.imports.start(
+    return context.imports.record_import_start(
         profile=args.profile,
-        app_key=args.app,
-        verification_id=args.verification,
-        being_enter_auditing=bool(args.enter_auditing),
-        view_key=args.view,
+        app_key=args.app_key,
+        verification_id=args.verification_id,
+        being_enter_auditing=bool(args.being_enter_auditing),
+        view_key=args.view_key,
     )
 
 
 def _handle_status(args: argparse.Namespace, context: CliContext) -> dict:
-    return context.imports.status(
+    return context.imports.record_import_status_get(
         profile=args.profile,
-        app_key=args.app,
+        app_key=args.app_key,
         import_id=args.import_id,
-        process_id_str=args.process_id,
+        process_id_str=args.process_id_str,
     )

package/src/qingflow_mcp/cli/commands/record.py

@@ -5,200 +5,198 @@ from typing import Any
 
 from ...errors import QingflowApiError
 from ..context import CliContext
-from .common import add_field_args, add_file_arg, add_stdin_json_flag, load_list_input, load_object_input, merge_object_inputs
+from .common import load_list_arg, load_object_arg, require_list_arg, require_object_arg
 
 
 def register(subparsers: argparse._SubParsersAction[argparse.ArgumentParser]) -> None:
-    parser = subparsers.add_parser("records", help="记录与表结构")
-    record_subparsers = parser.add_subparsers(dest="records_command", required=True)
+    parser = subparsers.add_parser("record", help="记录与表结构")
+    record_subparsers = parser.add_subparsers(dest="record_command", required=True)
 
-    schema = record_subparsers.add_parser("schema", help="读取记录表结构")
-    schema.add_argument("--app", required=True)
+    schema = record_subparsers.add_parser("schema", help="读取记录相关表结构")
+    schema.add_argument("--app-key", required=True)
     schema.add_argument("--mode", choices=["applicant", "browse", "insert", "update", "import", "code-block"], default="applicant")
-    schema.add_argument("--view")
-    schema.add_argument("--record", type=int)
-    schema.set_defaults(handler=_handle_schema, format_hint="record_schema")
+    schema.add_argument("--view-id")
+    schema.add_argument("--record-id", type=int)
+    schema.set_defaults(handler=_handle_schema, format_hint="")
 
     list_parser = record_subparsers.add_parser("list", help="列出记录")
-    list_parser.add_argument("--app", required=True)
-    list_parser.add_argument("--view")
+    list_parser.add_argument("--app-key", required=True)
     list_parser.add_argument("--column", dest="columns", action="append", type=int, default=[])
+    list_parser.add_argument("--columns-file")
+    list_parser.add_argument("--where-file")
+    list_parser.add_argument("--order-by-file")
     list_parser.add_argument("--limit", type=int, default=20)
     list_parser.add_argument("--page", type=int, default=1)
-    add_file_arg(list_parser)
-    add_stdin_json_flag(list_parser)
-    list_parser.set_defaults(handler=_handle_list, format_hint="records_list")
+    list_parser.add_argument("--view-id")
+    list_parser.set_defaults(handler=_handle_list, format_hint="record_list")
 
     get = record_subparsers.add_parser("get", help="读取单条记录")
-    get.add_argument("--app", required=True)
-    get.add_argument("--record", required=True, type=int)
-    get.add_argument("--view")
+    get.add_argument("--app-key", required=True)
+    get.add_argument("--record-id", required=True, type=int)
     get.add_argument("--column", dest="columns", action="append", type=int, default=[])
-    get.set_defaults(handler=_handle_get, format_hint="record_show")
+    get.add_argument("--columns-file")
+    get.add_argument("--view-id")
+    get.set_defaults(handler=_handle_get, format_hint="")
 
-    create = record_subparsers.add_parser("create", help="新增记录")
-    create.add_argument("--app", required=True)
-    add_field_args(create)
-    add_file_arg(create)
-    add_stdin_json_flag(create)
-    create.add_argument("--verify-write", action=argparse.BooleanOptionalAction, default=True)
-    create.set_defaults(handler=_handle_create, format_hint="record_write")
+    insert = record_subparsers.add_parser("insert", help="新增记录")
+    insert.add_argument("--app-key", required=True)
+    insert.add_argument("--fields-file", required=True)
+    insert.add_argument("--verify-write", action=argparse.BooleanOptionalAction, default=True)
+    insert.set_defaults(handler=_handle_insert, format_hint="")
 
     update = record_subparsers.add_parser("update", help="更新记录")
-    update.add_argument("--app", required=True)
-    update.add_argument("--record", required=True, type=int)
-    add_field_args(update)
-    add_file_arg(update)
-    add_stdin_json_flag(update)
+    update.add_argument("--app-key", required=True)
+    update.add_argument("--record-id", required=True, type=int)
+    update.add_argument("--fields-file", required=True)
     update.add_argument("--verify-write", action=argparse.BooleanOptionalAction, default=True)
-    update.set_defaults(handler=_handle_update, format_hint="record_write")
+    update.set_defaults(handler=_handle_update, format_hint="")
 
     delete = record_subparsers.add_parser("delete", help="删除记录")
-    delete.add_argument("--app", required=True)
-    delete.add_argument("--record", type=int)
-    add_file_arg(delete)
-    add_stdin_json_flag(delete)
-    delete.set_defaults(handler=_handle_delete, format_hint="record_write")
+    delete.add_argument("--app-key", required=True)
+    delete.add_argument("--record-id", type=int)
+    delete.add_argument("--record-ids-file")
+    delete.set_defaults(handler=_handle_delete, format_hint="")
 
     analyze = record_subparsers.add_parser("analyze", help="分析记录数据")
-    analyze.add_argument("--app", required=True)
-    analyze.add_argument("--view")
+    analyze.add_argument("--app-key", required=True)
+    analyze.add_argument("--dimensions-file")
+    analyze.add_argument("--metrics-file")
+    analyze.add_argument("--filters-file")
+    analyze.add_argument("--sort-file")
     analyze.add_argument("--limit", type=int, default=20)
     analyze.add_argument("--strict-full", action=argparse.BooleanOptionalAction, default=False)
-    add_file_arg(analyze, required=False, help_text="读取分析 JSON，支持 dimensions/metrics/filters/sort")
-    add_stdin_json_flag(analyze)
-    analyze.set_defaults(handler=_handle_analyze, format_hint="record_analyze")
-
-    run_code = record_subparsers.add_parser("run-code", help="执行代码块字段")
-    run_code.add_argument("--app", required=True)
-    run_code.add_argument("--record", required=True, type=int)
-    run_code.add_argument("--field-selector", required=True)
-    run_code.add_argument("--role", type=int, default=1)
-    run_code.add_argument("--node", dest="workflow_node_id", type=int)
-    add_file_arg(run_code, required=False, help_text="读取执行 JSON，支持 answers/fields")
-    add_stdin_json_flag(run_code)
-    run_code.add_argument("--manual", action=argparse.BooleanOptionalAction, default=True)
-    run_code.add_argument("--verify-writeback", action=argparse.BooleanOptionalAction, default=True)
-    run_code.add_argument("--force-refresh-form", action="store_true")
-    run_code.set_defaults(handler=_handle_run_code, format_hint="record_run_code")
+    analyze.add_argument("--view-id")
+    analyze.set_defaults(handler=_handle_analyze, format_hint="")
+
+    code_block = record_subparsers.add_parser("code-block-run", help="执行代码块字段")
+    code_block.add_argument("--app-key", required=True)
+    code_block.add_argument("--record-id", required=True, type=int)
+    code_block.add_argument("--code-block-field", required=True)
+    code_block.add_argument("--role", type=int, default=1)
+    code_block.add_argument("--workflow-node-id", type=int)
+    code_block.add_argument("--answers-file")
+    code_block.add_argument("--fields-file")
+    code_block.add_argument("--manual", action=argparse.BooleanOptionalAction, default=True)
+    code_block.add_argument("--verify-writeback", action=argparse.BooleanOptionalAction, default=True)
+    code_block.add_argument("--force-refresh-form", action="store_true")
+    code_block.set_defaults(handler=_handle_code_block_run, format_hint="")
+
+
+def _columns(args: argparse.Namespace) -> list[Any]:
+    columns: list[Any] = list(args.columns or [])
+    if args.columns_file:
+        columns.extend(require_list_arg(args.columns_file, option_name="--columns-file"))
+    return columns
 
 
 def _handle_schema(args: argparse.Namespace, context: CliContext) -> dict:
-    if args.mode == "browse" and not args.view:
-        raise QingflowApiError.config_error("--view is required when --mode browse")
-    if args.mode == "update" and not args.record:
-        raise QingflowApiError.config_error("--record is required when --mode update")
-    return context.records.schema(
-        profile=args.profile,
-        app_key=args.app,
-        mode=args.mode,
-        view_id=args.view,
-        record_id=args.record,
-    )
+    mode = args.mode
+    if mode == "applicant":
+        return context.record.record_schema_get(
+            profile=args.profile,
+            app_key=args.app_key,
+            schema_mode="applicant",
+        )
+    if mode == "browse":
+        if not args.view_id:
+            raise QingflowApiError.config_error("--view-id is required when --mode browse")
+        return context.record.record_browse_schema_get_public(
+            profile=args.profile,
+            app_key=args.app_key,
+            view_id=args.view_id,
+        )
+    if mode == "insert":
+        return context.record.record_insert_schema_get_public(profile=args.profile, app_key=args.app_key)
+    if mode == "update":
+        if not args.record_id:
+            raise QingflowApiError.config_error("--record-id is required when --mode update")
+        return context.record.record_update_schema_get_public(
+            profile=args.profile,
+            app_key=args.app_key,
+            record_id=args.record_id,
+        )
+    if mode == "import":
+        return context.imports.record_import_schema_get(profile=args.profile, app_key=args.app_key)
+    return context.code_block.record_code_block_schema_get_public(profile=args.profile, app_key=args.app_key)
 
 
 def _handle_list(args: argparse.Namespace, context: CliContext) -> dict:
-    query = _load_query_payload(args)
-    return context.records.list(
+    return context.record.record_list(
         profile=args.profile,
-        app_key=args.app,
-        columns=list(args.columns or []) + _coerce_list(query.get("columns")),
-        where=_coerce_list(query.get("where")),
-        order_by=_coerce_list(query.get("order_by")),
-        limit=int(query.get("limit") or args.limit),
-        page=int(query.get("page") or args.page),
-        view_id=str(query.get("view_id") or args.view or "") or None,
-        list_type=None,
-        view_key=None,
-        view_name=None,
+        app_key=args.app_key,
+        columns=_columns(args),
+        where=load_list_arg(args.where_file, option_name="--where-file"),
+        order_by=load_list_arg(args.order_by_file, option_name="--order-by-file"),
+        limit=args.limit,
+        page=args.page,
+        view_id=args.view_id,
     )
 
 
 def _handle_get(args: argparse.Namespace, context: CliContext) -> dict:
-    return context.records.get(
+    return context.record.record_get_public(
         profile=args.profile,
-        app_key=args.app,
-        record_id=args.record,
-        columns=list(args.columns or []),
-        view_id=args.view,
-        workflow_node_id=None,
+        app_key=args.app_key,
+        record_id=args.record_id,
+        columns=_columns(args),
+        view_id=args.view_id,
     )
 
 
-def _handle_create(args: argparse.Namespace, context: CliContext) -> dict:
-    return context.records.create(
+def _handle_insert(args: argparse.Namespace, context: CliContext) -> dict:
+    return context.record.record_insert_public(
         profile=args.profile,
-        app_key=args.app,
-        fields=merge_object_inputs(args),
+        app_key=args.app_key,
+        fields=require_object_arg(args.fields_file, option_name="--fields-file"),
         verify_write=bool(args.verify_write),
     )
 
 
 def _handle_update(args: argparse.Namespace, context: CliContext) -> dict:
-    return context.records.update(
+    return context.record.record_update_public(
         profile=args.profile,
-        app_key=args.app,
-        record_id=args.record,
-        fields=merge_object_inputs(args),
+        app_key=args.app_key,
+        record_id=args.record_id,
+        fields=require_object_arg(args.fields_file, option_name="--fields-file"),
         verify_write=bool(args.verify_write),
     )
 
 
 def _handle_delete(args: argparse.Namespace, context: CliContext) -> dict:
-    record_ids = []
-    if args.stdin_json or args.file:
-        payload = load_list_input(args, required=False)
-        record_ids = [item for item in payload if isinstance(item, int)]
-    return context.records.delete(
+    record_ids = load_list_arg(args.record_ids_file, option_name="--record-ids-file")
+    return context.record.record_delete_public(
         profile=args.profile,
-        app_key=args.app,
-        record_id=args.record,
+        app_key=args.app_key,
+        record_id=args.record_id,
         record_ids=record_ids,
     )
 
 
 def _handle_analyze(args: argparse.Namespace, context: CliContext) -> dict:
-    payload = load_object_input(args, required=False)
-    return context.records.analyze(
+    return context.record.record_analyze(
         profile=args.profile,
-        app_key=args.app,
-        dimensions=_coerce_list(payload.get("dimensions")),
-        metrics=_coerce_list(payload.get("metrics")),
-        filters=_coerce_list(payload.get("filters")),
-        sort=_coerce_list(payload.get("sort")),
-        limit=int(payload.get("limit") or args.limit),
-        strict_full=bool(payload.get("strict_full", args.strict_full)),
-        view_id=str(payload.get("view_id") or args.view or "") or None,
-        list_type=None,
-        view_key=None,
-        view_name=None,
+        app_key=args.app_key,
+        dimensions=load_list_arg(args.dimensions_file, option_name="--dimensions-file"),
+        metrics=load_list_arg(args.metrics_file, option_name="--metrics-file"),
+        filters=load_list_arg(args.filters_file, option_name="--filters-file"),
+        sort=load_list_arg(args.sort_file, option_name="--sort-file"),
+        limit=args.limit,
+        strict_full=bool(args.strict_full),
+        view_id=args.view_id,
     )
 
 
-def _handle_run_code(args: argparse.Namespace, context: CliContext) -> dict:
-    payload = load_object_input(args, required=False)
-    return context.records.run_code(
+def _handle_code_block_run(args: argparse.Namespace, context: CliContext) -> dict:
+    return context.code_block.record_code_block_run(
         profile=args.profile,
-        app_key=args.app,
-        record_id=args.record,
-        code_block_field=args.field_selector,
+        app_key=args.app_key,
+        record_id=args.record_id,
+        code_block_field=args.code_block_field,
         role=args.role,
         workflow_node_id=args.workflow_node_id,
-        answers=_coerce_list(payload.get("answers")),
-        fields=payload.get("fields") if isinstance(payload.get("fields"), dict) else {},
-        manual=bool(payload.get("manual", args.manual)),
-        verify_writeback=bool(payload.get("verify_writeback", args.verify_writeback)),
-        force_refresh_form=bool(payload.get("force_refresh_form", args.force_refresh_form)),
+        answers=load_list_arg(args.answers_file, option_name="--answers-file"),
+        fields=load_object_arg(args.fields_file, option_name="--fields-file") or {},
+        manual=bool(args.manual),
+        verify_writeback=bool(args.verify_writeback),
+        force_refresh_form=bool(args.force_refresh_form),
     )
-
-
-def _load_query_payload(args: argparse.Namespace) -> dict[str, Any]:
-    if args.stdin_json or args.file:
-        payload = load_object_input(args, required=False)
-        if payload:
-            return payload
-    return {}
-
-
-def _coerce_list(value: Any) -> list[Any]:
-    return value if isinstance(value, list) else []

package/src/qingflow_mcp/cli/commands/task.py

@@ -3,53 +3,52 @@ from __future__ import annotations
 import argparse
 
 from ..context import CliContext
-from .common import add_file_arg, add_stdin_json_flag, load_object_input
+from .common import load_object_arg
 
 
 def register(subparsers: argparse._SubParsersAction[argparse.ArgumentParser]) -> None:
-    parser = subparsers.add_parser("tasks", help="待办与流程上下文")
-    task_subparsers = parser.add_subparsers(dest="tasks_command", required=True)
+    parser = subparsers.add_parser("task", help="待办与流程上下文")
+    task_subparsers = parser.add_subparsers(dest="task_command", required=True)
 
     list_parser = task_subparsers.add_parser("list", help="列出待办")
     list_parser.add_argument("--task-box", default="todo")
     list_parser.add_argument("--flow-status", default="all")
-    list_parser.add_argument("--app")
-    list_parser.add_argument("--node", dest="workflow_node_id", type=int)
+    list_parser.add_argument("--app-key")
+    list_parser.add_argument("--workflow-node-id", type=int)
     list_parser.add_argument("--query")
     list_parser.add_argument("--page", type=int, default=1)
     list_parser.add_argument("--page-size", type=int, default=20)
-    list_parser.set_defaults(handler=_handle_list, format_hint="tasks_list")
-
-    show = task_subparsers.add_parser("show", help="读取待办详情")
-    show.add_argument("--app", required=True)
-    show.add_argument("--record", required=True, type=int)
-    show.add_argument("--node", required=True, type=int)
-    show.add_argument("--include-candidates", action=argparse.BooleanOptionalAction, default=True)
-    show.add_argument("--include-associated-reports", action=argparse.BooleanOptionalAction, default=True)
-    show.set_defaults(handler=_handle_show, format_hint="task_show")
-
-    act = task_subparsers.add_parser("act", help="执行待办动作")
-    act.add_argument("--app", required=True)
-    act.add_argument("--record", required=True, type=int)
-    act.add_argument("--node", required=True, type=int)
-    act.add_argument("--action", required=True)
-    add_file_arg(act)
-    add_stdin_json_flag(act)
-    act.set_defaults(handler=_handle_act, format_hint="task_action")
+    list_parser.set_defaults(handler=_handle_list, format_hint="task_list")
+
+    get = task_subparsers.add_parser("get", help="读取待办详情")
+    get.add_argument("--app-key", required=True)
+    get.add_argument("--record-id", required=True, type=int)
+    get.add_argument("--workflow-node-id", required=True, type=int)
+    get.add_argument("--include-candidates", action=argparse.BooleanOptionalAction, default=True)
+    get.add_argument("--include-associated-reports", action=argparse.BooleanOptionalAction, default=True)
+    get.set_defaults(handler=_handle_get, format_hint="")
+
+    action = task_subparsers.add_parser("action", help="执行待办动作")
+    action.add_argument("--app-key", required=True)
+    action.add_argument("--record-id", required=True, type=int)
+    action.add_argument("--workflow-node-id", required=True, type=int)
+    action.add_argument("--action", required=True)
+    action.add_argument("--payload-file")
+    action.set_defaults(handler=_handle_action, format_hint="")
 
     log = task_subparsers.add_parser("log", help="读取流程日志")
-    log.add_argument("--app", required=True)
-    log.add_argument("--record", required=True, type=int)
-    log.add_argument("--node", required=True, type=int)
-    log.set_defaults(handler=_handle_log, format_hint="task_log")
+    log.add_argument("--app-key", required=True)
+    log.add_argument("--record-id", required=True, type=int)
+    log.add_argument("--workflow-node-id", required=True, type=int)
+    log.set_defaults(handler=_handle_log, format_hint="")
 
 
 def _handle_list(args: argparse.Namespace, context: CliContext) -> dict:
-    return context.tasks.list(
+    return context.task.task_list(
         profile=args.profile,
         task_box=args.task_box,
         flow_status=args.flow_status,
-        app_key=args.app,
+        app_key=args.app_key,
         workflow_node_id=args.workflow_node_id,
         query=args.query,
         page=args.page,
@@ -57,32 +56,32 @@ def _handle_list(args: argparse.Namespace, context: CliContext) -> dict:
     )
 
 
-def _handle_show(args: argparse.Namespace, context: CliContext) -> dict:
-    return context.tasks.show(
+def _handle_get(args: argparse.Namespace, context: CliContext) -> dict:
+    return context.task.task_get(
         profile=args.profile,
-        app_key=args.app,
-        record_id=args.record,
-        workflow_node_id=args.node,
+        app_key=args.app_key,
+        record_id=args.record_id,
+        workflow_node_id=args.workflow_node_id,
         include_candidates=bool(args.include_candidates),
         include_associated_reports=bool(args.include_associated_reports),
     )
 
 
-def _handle_act(args: argparse.Namespace, context: CliContext) -> dict:
-    return context.tasks.act(
+def _handle_action(args: argparse.Namespace, context: CliContext) -> dict:
+    return context.task.task_action_execute(
         profile=args.profile,
-        app_key=args.app,
-        record_id=args.record,
-        workflow_node_id=args.node,
+        app_key=args.app_key,
+        record_id=args.record_id,
+        workflow_node_id=args.workflow_node_id,
         action=args.action,
-        payload=load_object_input(args, required=False),
+        payload=load_object_arg(args.payload_file, option_name="--payload-file") or {},
     )
 
 
 def _handle_log(args: argparse.Namespace, context: CliContext) -> dict:
-    return context.tasks.log(
+    return context.task.task_workflow_log_get(
         profile=args.profile,
-        app_key=args.app,
-        record_id=args.record,
-        workflow_node_id=args.node,
+        app_key=args.app_key,
+        record_id=args.record_id,
+        workflow_node_id=args.workflow_node_id,
     )

package/src/qingflow_mcp/cli/commands/workspace.py

@@ -6,22 +6,22 @@ from ..context import CliContext
 
 
 def register(subparsers: argparse._SubParsersAction[argparse.ArgumentParser]) -> None:
-    parser = subparsers.add_parser("ws", help="工作区操作")
-    ws_subparsers = parser.add_subparsers(dest="ws_command", required=True)
+    parser = subparsers.add_parser("workspace", help="工作区")
+    workspace_subparsers = parser.add_subparsers(dest="workspace_command", required=True)
 
-    list_parser = ws_subparsers.add_parser("list", help="列出工作区")
+    list_parser = workspace_subparsers.add_parser("list", help="列出工作区")
     list_parser.add_argument("--page", type=int, default=1)
     list_parser.add_argument("--page-size", type=int, default=20)
     list_parser.add_argument("--include-external", action="store_true")
-    list_parser.set_defaults(handler=_handle_list, format_hint="ws_list")
+    list_parser.set_defaults(handler=_handle_list, format_hint="workspace_list")
 
-    use = ws_subparsers.add_parser("use", help="切换工作区")
-    use.add_argument("--ws-id", type=int, required=True)
-    use.set_defaults(handler=_handle_use, format_hint="ws_use")
+    select = workspace_subparsers.add_parser("select", help="切换工作区")
+    select.add_argument("--ws-id", type=int, required=True)
+    select.set_defaults(handler=_handle_select, format_hint="")
 
 
 def _handle_list(args: argparse.Namespace, context: CliContext) -> dict:
-    return context.workspace.list(
+    return context.workspace.workspace_list(
         profile=args.profile,
         page_num=args.page,
         page_size=args.page_size,
@@ -29,5 +29,5 @@ def _handle_list(args: argparse.Namespace, context: CliContext) -> dict:
     )
 
 
-def _handle_use(args: argparse.Namespace, context: CliContext) -> dict:
-    return context.workspace.use(profile=args.profile, ws_id=args.ws_id)
+def _handle_select(args: argparse.Namespace, context: CliContext) -> dict:
+    return context.workspace.workspace_select(profile=args.profile, ws_id=args.ws_id)