@yinuo-ngm/mcp-server 0.1.1 → 0.1.3

package/lib/tools/hub-v2/rd.tools.js

@@ -0,0 +1,361 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hubV2RdTools = hubV2RdTools;
+const client_1 = require("./client");
+const index_1 = require("./config/index");
+const schemas_1 = require("./schemas");
+const result_1 = require("../../utils/result");
+const raw_1 = require("./raw");
+function hubV2RdTools() {
+    return [
+        {
+            name: "hub_v2_rd_list",
+            description: "List Hub V2 RD items with Project Token.",
+            riskLevel: "read",
+            inputSchema: schemas_1.rdListSchema,
+            async handler(args) {
+                const ctx = (0, index_1.resolveHubV2Context)(args, "project");
+                const client = new client_1.HubV2Client(ctx);
+                const data = await client.request("GET", client.tokenUrl("/rd-items", {
+                    page: args.page ?? 1,
+                    pageSize: args.pageSize ?? 20,
+                    keyword: args.keyword,
+                    stageId: args.stageId,
+                    status: args.status,
+                    type: args.type,
+                    priority: args.priority,
+                    assigneeId: args.assigneeId,
+                }));
+                return (0, result_1.ok)("hub_v2_rd_list", data);
+            },
+        },
+        {
+            name: "hub_v2_rd_get",
+            description: "Read one Hub V2 RD item by id with Project Token.",
+            riskLevel: "read",
+            inputSchema: schemas_1.rdGetSchema,
+            async handler(args) {
+                const ctx = (0, index_1.resolveHubV2Context)(args, "project");
+                const client = new client_1.HubV2Client(ctx);
+                const data = await client.request("GET", client.tokenUrl(`/rd-items/${encodeURIComponent(args.itemId)}`));
+                return (0, result_1.ok)("hub_v2_rd_get", data);
+            },
+        },
+        {
+            name: "hub_v2_rd_stages_list",
+            description: "List Hub V2 RD stage dictionary with Project Token.",
+            riskLevel: "read",
+            inputSchema: schemas_1.projectSelectorSchema,
+            async handler(args) {
+                const ctx = (0, index_1.resolveHubV2Context)(args, "project");
+                const client = new client_1.HubV2Client(ctx);
+                const data = await client.request("GET", client.tokenUrl("/rd-stages"));
+                return (0, result_1.ok)("hub_v2_rd_stages_list", data);
+            },
+        },
+        rdReadTool("hub_v2_rd_logs_list", "List Hub V2 RD item logs with Project Token.", "logs"),
+        rdReadTool("hub_v2_rd_stage_history_list", "List Hub V2 RD item stage history with Project Token.", "stage-history"),
+        {
+            name: "hub_v2_rd_stage_tasks_list",
+            description: "List Hub V2 RD current stage tasks with Project Token.",
+            riskLevel: "read",
+            inputSchema: schemas_1.rdStageTasksListSchema,
+            async handler(args) {
+                const ctx = (0, index_1.resolveHubV2Context)(args, "project");
+                const client = new client_1.HubV2Client(ctx);
+                const data = await client.request("GET", client.tokenUrl(`/rd-items/${encodeURIComponent(args.itemId)}/stage-tasks`));
+                return (0, result_1.ok)("hub_v2_rd_stage_tasks_list", data);
+            },
+        },
+        rdReadTool("hub_v2_rd_progress_list", "List Hub V2 RD item member progress with Project Token.", "progress"),
+        rdReadTool("hub_v2_rd_progress_history_list", "List Hub V2 RD item progress history with Project Token.", "progress/history"),
+        {
+            name: "hub_v2_rd_upload_raw_get",
+            description: "Read one Hub V2 RD Markdown upload raw file as base64 with Project Token.",
+            riskLevel: "read",
+            inputSchema: schemas_1.rdUploadRawSchema,
+            async handler(args) {
+                const ctx = (0, index_1.resolveHubV2Context)(args, "project");
+                const client = new client_1.HubV2Client(ctx);
+                const data = await (0, raw_1.readRawAsBase64)(client, client.tokenUrl(`/rd-items/${encodeURIComponent(args.itemId)}/uploads/${encodeURIComponent(args.uploadId)}/raw`), args.maxBytes);
+                return (0, result_1.ok)("hub_v2_rd_upload_raw_get", data);
+            },
+        },
+        {
+            name: "hub_v2_rd_create",
+            description: "Preview or create a Hub V2 RD item with Personal Token.",
+            riskLevel: "write",
+            inputSchema: schemas_1.rdCreateSchema,
+            allowPreviewWhenBlocked: true,
+            isConfirmed: (args) => args.confirm === true,
+            async handler(args) {
+                const path = "/rd-items";
+                const body = (0, client_1.compact)({
+                    title: args.title,
+                    description: args.description,
+                    stageId: args.stageId,
+                    type: args.type,
+                    priority: args.priority,
+                    memberIds: args.memberIds,
+                    verifierId: args.verifierId,
+                    planStartAt: args.planStartAt,
+                    planEndAt: args.planEndAt,
+                    stageTasks: args.stageTasks,
+                    stageTaskTemplates: args.stageTaskTemplates,
+                });
+                if (!args.confirm) {
+                    return (0, result_1.ok)("hub_v2_rd_create", {
+                        code: "PREVIEW",
+                        message: "set confirm=true to execute this write operation",
+                        data: {
+                            method: "POST",
+                            path,
+                            requiredScope: "rd:create:write",
+                            body,
+                        },
+                    });
+                }
+                const ctx = (0, index_1.resolveHubV2Context)(args, "personal");
+                const client = new client_1.HubV2Client(ctx);
+                const data = await client.request("POST", client.personalUrl(path), body);
+                return (0, result_1.ok)("hub_v2_rd_create", data);
+            },
+        },
+        {
+            name: "hub_v2_rd_advance_stage",
+            description: "Preview or execute Hub V2 RD stage advance with Personal Token.",
+            riskLevel: "write",
+            inputSchema: schemas_1.rdAdvanceStageSchema,
+            allowPreviewWhenBlocked: true,
+            isConfirmed: (args) => args.confirm === true,
+            async handler(args) {
+                const path = `/rd-items/${encodeURIComponent(args.itemId)}/advance-stage`;
+                const body = (0, client_1.compact)({
+                    stageId: args.stageId,
+                    memberIds: args.memberIds,
+                    description: args.description,
+                    planStartAt: args.planStartAt,
+                    planEndAt: args.planEndAt,
+                    stageTasks: args.stageTasks,
+                    stageTaskTemplates: args.stageTaskTemplates,
+                });
+                if (!args.confirm) {
+                    return (0, result_1.ok)("hub_v2_rd_advance_stage", {
+                        code: "PREVIEW",
+                        message: "set confirm=true to execute this write operation",
+                        data: {
+                            method: "POST",
+                            path,
+                            requiredScope: "rd:transition:write",
+                            body,
+                        },
+                    });
+                }
+                const ctx = (0, index_1.resolveHubV2Context)(args, "personal");
+                const client = new client_1.HubV2Client(ctx);
+                const data = await client.request("POST", client.personalUrl(path), body);
+                return (0, result_1.ok)("hub_v2_rd_advance_stage", data);
+            },
+        },
+        rdSimpleWriteTool("hub_v2_rd_start", "Preview or start a Hub V2 RD item with Personal Token.", "start"),
+        {
+            name: "hub_v2_rd_block",
+            description: "Preview or block a Hub V2 RD item with Personal Token.",
+            riskLevel: "write",
+            inputSchema: schemas_1.rdBlockSchema,
+            allowPreviewWhenBlocked: true,
+            isConfirmed: (args) => args.confirm === true,
+            async handler(args) {
+                return rdBodyWrite("hub_v2_rd_block", args, "block", {
+                    blockerReason: args.blockerReason,
+                });
+            },
+        },
+        rdSimpleWriteTool("hub_v2_rd_resume", "Preview or resume a Hub V2 RD item with Personal Token.", "resume"),
+        {
+            name: "hub_v2_rd_complete",
+            description: "Preview or complete a Hub V2 RD item with Personal Token.",
+            riskLevel: "write",
+            inputSchema: schemas_1.rdCompleteSchema,
+            allowPreviewWhenBlocked: true,
+            isConfirmed: (args) => args.confirm === true,
+            async handler(args) {
+                return rdBodyWrite("hub_v2_rd_complete", args, "complete", {
+                    reason: args.reason,
+                });
+            },
+        },
+        rdSimpleWriteTool("hub_v2_rd_accept", "Preview or accept a Hub V2 RD item with Personal Token.", "accept"),
+        rdSimpleWriteTool("hub_v2_rd_reopen", "Preview or reopen a Hub V2 RD item with Personal Token.", "reopen"),
+        {
+            name: "hub_v2_rd_close",
+            description: "Preview or close a Hub V2 RD item with Personal Token.",
+            riskLevel: "write",
+            inputSchema: schemas_1.rdCloseSchema,
+            allowPreviewWhenBlocked: true,
+            isConfirmed: (args) => args.confirm === true,
+            async handler(args) {
+                return rdBodyWrite("hub_v2_rd_close", args, "close", {
+                    reason: args.reason,
+                });
+            },
+        },
+        {
+            name: "hub_v2_rd_stage_tasks_create",
+            description: "Preview or create a Hub V2 RD stage task on the current stage with Personal Token.",
+            riskLevel: "write",
+            inputSchema: schemas_1.rdStageTaskCreateSchema,
+            allowPreviewWhenBlocked: true,
+            isConfirmed: (args) => args.confirm === true,
+            async handler(args) {
+                const path = `/rd-items/${encodeURIComponent(args.itemId)}/stage-tasks`;
+                const body = (0, client_1.compact)({
+                    title: args.title,
+                    description: args.description,
+                    ownerIds: args.ownerIds,
+                    plannedStartAt: args.plannedStartAt,
+                    plannedEndAt: args.plannedEndAt,
+                    sortOrder: args.sortOrder,
+                    remark: args.remark,
+                });
+                if (!args.confirm) {
+                    return (0, result_1.ok)("hub_v2_rd_stage_tasks_create", {
+                        code: "PREVIEW",
+                        message: "set confirm=true to execute this write operation",
+                        data: {
+                            method: "POST",
+                            path,
+                            requiredScope: "rd:stage-task:write",
+                            body,
+                        },
+                    });
+                }
+                const ctx = (0, index_1.resolveHubV2Context)(args, "personal");
+                const client = new client_1.HubV2Client(ctx);
+                const data = await client.request("POST", client.personalUrl(path), body);
+                return (0, result_1.ok)("hub_v2_rd_stage_tasks_create", data);
+            },
+        },
+        {
+            name: "hub_v2_rd_update_progress",
+            description: "Preview or update Hub V2 RD progress with Personal Token.",
+            riskLevel: "write",
+            inputSchema: schemas_1.rdUpdateProgressSchema,
+            allowPreviewWhenBlocked: true,
+            isConfirmed: (args) => args.confirm === true,
+            async handler(args) {
+                const path = `/rd-items/${encodeURIComponent(args.itemId)}/progress`;
+                const body = (0, client_1.compact)({
+                    progress: args.progress,
+                    note: args.note,
+                    blockReason: args.blockReason,
+                    resolveBlockId: args.resolveBlockId,
+                    stageTaskId: args.stageTaskId,
+                });
+                if (!args.confirm) {
+                    return (0, result_1.ok)("hub_v2_rd_update_progress", {
+                        code: "PREVIEW",
+                        message: "set confirm=true to execute this write operation",
+                        data: {
+                            method: "POST",
+                            path,
+                            requiredScope: "rd:progress:write or rd:transition:write",
+                            body,
+                        },
+                    });
+                }
+                const ctx = (0, index_1.resolveHubV2Context)(args, "personal");
+                const client = new client_1.HubV2Client(ctx);
+                const data = await client.request("POST", client.personalUrl(path), body);
+                return (0, result_1.ok)("hub_v2_rd_update_progress", data);
+            },
+        },
+        {
+            name: "hub_v2_rd_update",
+            description: "Preview or update Hub V2 RD item basic fields with Personal Token.",
+            riskLevel: "write",
+            inputSchema: schemas_1.rdUpdateSchema,
+            allowPreviewWhenBlocked: true,
+            isConfirmed: (args) => args.confirm === true,
+            async handler(args) {
+                const path = `/rd-items/${encodeURIComponent(args.itemId)}`;
+                const body = (0, client_1.compactUndefined)({
+                    version: args.version,
+                    title: args.title,
+                    description: args.description,
+                    stageId: args.stageId,
+                    type: args.type,
+                    priority: args.priority,
+                    memberIds: args.memberIds,
+                    verifierId: args.verifierId,
+                    planStartAt: args.planStartAt,
+                    planEndAt: args.planEndAt,
+                    stageDescription: args.stageDescription,
+                });
+                if (!args.confirm) {
+                    return (0, result_1.ok)("hub_v2_rd_update", {
+                        code: "PREVIEW",
+                        message: "set confirm=true to execute this write operation",
+                        data: {
+                            method: "PATCH",
+                            path,
+                            requiredScope: "rd:edit:write",
+                            body,
+                        },
+                    });
+                }
+                const ctx = (0, index_1.resolveHubV2Context)(args, "personal");
+                const client = new client_1.HubV2Client(ctx);
+                const data = await client.request("PATCH", client.personalUrl(path), body, { preserveNull: true });
+                return (0, result_1.ok)("hub_v2_rd_update", data);
+            },
+        },
+    ];
+}
+function rdReadTool(name, description, suffix) {
+    return {
+        name,
+        description,
+        riskLevel: "read",
+        inputSchema: schemas_1.rdReadDetailSchema,
+        async handler(args) {
+            const ctx = (0, index_1.resolveHubV2Context)(args, "project");
+            const client = new client_1.HubV2Client(ctx);
+            const data = await client.request("GET", client.tokenUrl(`/rd-items/${encodeURIComponent(args.itemId)}/${suffix}`));
+            return (0, result_1.ok)(name, data);
+        },
+    };
+}
+function rdSimpleWriteTool(name, description, suffix) {
+    return {
+        name,
+        description,
+        riskLevel: "write",
+        inputSchema: schemas_1.rdSimpleWriteSchema,
+        allowPreviewWhenBlocked: true,
+        isConfirmed: (args) => args.confirm === true,
+        async handler(args) {
+            return rdBodyWrite(name, args, suffix);
+        },
+    };
+}
+async function rdBodyWrite(name, args, suffix, body = {}) {
+    const path = `/rd-items/${encodeURIComponent(args.itemId)}/${suffix}`;
+    const compactBody = (0, client_1.compact)(body);
+    if (!args.confirm) {
+        return (0, result_1.ok)(name, {
+            code: "PREVIEW",
+            message: "set confirm=true to execute this write operation",
+            data: {
+                method: "POST",
+                path,
+                requiredScope: "rd:transition:write",
+                ...(Object.keys(compactBody).length > 0 ? { body: compactBody } : {}),
+            },
+        });
+    }
+    const ctx = (0, index_1.resolveHubV2Context)(args, "personal");
+    const client = new client_1.HubV2Client(ctx);
+    const data = await client.request("POST", client.personalUrl(path), compactBody);
+    return (0, result_1.ok)(name, data);
+}