@alternative-path/qa-path-mcp 1.0.0

package/dist/tools/testcase-tools.js

@@ -0,0 +1,845 @@
+import { jsonResponse } from "../utils/mcp-response.js";
+export class TestCaseTools {
+    apiClient;
+    projectContext;
+    constructor(apiClient, projectContext) {
+        this.apiClient = apiClient;
+        this.projectContext = projectContext;
+    }
+    getTools() {
+        return [
+            {
+                name: "list_test_cases",
+                description: "List test cases with filtering and sorting. Supports text-based queries in canonical format (e.g., \"status = 'New' AND priority = 'High'\"). IMPORTANT: Always call get_query_schema with entity='testcase' first to understand available fields, operators, and valid values. Use field names (not labels) in queries, and use IDs for association fields like generated_by_user, updated_by_user, and module.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        query: {
+                            type: "string",
+                            description: "Optional text query in canonical format (e.g., \"status = 'New' AND priority = 'High'\"). Leave empty or omit to get all test cases. Max length: 5000 characters.",
+                            maxLength: 5000,
+                        },
+                        page: {
+                            type: "number",
+                            description: "Page number for pagination (default: 1, minimum: 1)",
+                            minimum: 1,
+                            default: 1,
+                        },
+                        pageSize: {
+                            type: "number",
+                            description: "Number of results per page (default: 25, minimum: 1, maximum: 10000)",
+                            minimum: 1,
+                            maximum: 10000,
+                            default: 25,
+                        },
+                        moduleId: {
+                            type: ["string", "null"],
+                            description: "Optional module ID to filter test cases by module, or 'all'/'default' for all modules (default: 'all')",
+                        },
+                        sortField: {
+                            type: "string",
+                            description: "Optional field to sort by. Allowed values: key, title, type, priority, status, generated_by_user, created_at, updated_at, updated_by_user, estimated_duration, labels, last_executed_date, last_executed_by, key_counter, automation_status",
+                        },
+                        sortOrder: {
+                            type: "string",
+                            enum: ["asc", "desc", "ASC", "DESC"],
+                            description: "Sort order: 'asc'/'ASC' for ascending or 'desc'/'DESC' for descending",
+                        },
+                        timezone: {
+                            type: ["string", "null"],
+                            description: "Optional timezone for date parsing (e.g., 'UTC', 'Asia/Kolkata'). Max length: 100 characters. Default: 'UTC'",
+                            maxLength: 100,
+                        },
+                        projectId: {
+                            type: "string",
+                            description: "Optional project ID (UUID). If not provided, uses the active project set via 'set_active_project'. " +
+                                "If no active project is set, the tool will return an error with instructions on how to set one.",
+                        },
+                    },
+                },
+            },
+            {
+                name: "get_test_case",
+                description: "Get detailed information about a specific test case by ID",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        testCaseId: {
+                            type: "string",
+                            description: "ID of the test case to retrieve",
+                        },
+                        projectId: {
+                            type: "string",
+                            description: "Optional project ID (UUID). If not provided, uses the active project set via 'set_active_project'. " +
+                                "If no active project is set, the tool will return an error with instructions on how to set one.",
+                        },
+                    },
+                    required: ["testCaseId"],
+                },
+            },
+            {
+                name: "get_execution_history",
+                description: "Get execution history for a test case (runs, results, dates).",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        testCaseId: {
+                            type: "string",
+                            description: "ID (UUID) of the test case to get execution history for",
+                        },
+                        projectId: {
+                            type: "string",
+                            description: "Optional project ID (UUID). If not provided, uses the active project set via 'set_active_project'. " +
+                                "If no active project is set, the tool will return an error with instructions on how to set one.",
+                        },
+                        page: {
+                            type: "number",
+                            description: "Page number for pagination (default: 1)",
+                        },
+                        pageSize: {
+                            type: "number",
+                            description: "Number of results per page (default: 25)",
+                        },
+                    },
+                    required: ["testCaseId"],
+                },
+            },
+            {
+                name: "get_execution_plan",
+                description: "Get the exact details of the automated test steps (execution plan) for a test case. Returns the saved plan including steps, tool calls, assertions, and metadata. Use when you need the full automation script/plan for a test case (e.g. NLP-automated test).",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        testCaseId: {
+                            type: "string",
+                            description: "ID (UUID) of the test case to get the execution plan for",
+                        },
+                        projectId: {
+                            type: "string",
+                            description: "Optional project ID (UUID). If not provided, uses the active project set via 'set_active_project'. " +
+                                "If no active project is set, the tool will return an error with instructions on how to set one.",
+                        },
+                    },
+                    required: ["testCaseId"],
+                },
+            },
+            {
+                name: "create_test_case",
+                description: "Create a new test case in a specified module, component, or subcomponent",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        title: {
+                            type: "string",
+                            description: "Title/summary of the test case (required)",
+                        },
+                        description: {
+                            type: "string",
+                            description: "Detailed description of the test case",
+                        },
+                        moduleId: {
+                            type: "string",
+                            description: "ID of the module/component/subcomponent where the test case will be created (required)",
+                        },
+                        type: {
+                            type: "string",
+                            description: "Type of test case (e.g., 'Functional Test', 'Regression Test', 'Smoke Test')",
+                        },
+                        status: {
+                            type: "string",
+                            description: "Status of the test case (e.g., 'New', 'In Progress', 'Completed')",
+                        },
+                        priority: {
+                            type: "string",
+                            description: "Priority of the test case (e.g., 'Low', 'Normal', 'High', 'Critical')",
+                        },
+                        estimatedDuration: {
+                            type: "number",
+                            description: "Estimated duration in minutes",
+                        },
+                        testData: {
+                            type: "string",
+                            description: "Test data as JSON string",
+                        },
+                        labels: {
+                            type: "array",
+                            items: { type: "string" },
+                            description: "Array of label names to attach to the test case",
+                        },
+                        projectId: {
+                            type: "string",
+                            description: "Optional project ID (UUID). If not provided, uses the active project set via 'set_active_project'. " +
+                                "If no active project is set, the tool will return an error with instructions on how to set one.",
+                        },
+                    },
+                    required: ["title", "moduleId"],
+                },
+            },
+            {
+                name: "update_test_case",
+                description: "Update an existing test case. You can update any field of the test case.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        testCaseId: {
+                            type: "string",
+                            description: "ID of the test case to update (required)",
+                        },
+                        title: {
+                            type: "string",
+                            description: "New title for the test case",
+                        },
+                        description: {
+                            type: "string",
+                            description: "New description for the test case",
+                        },
+                        type: {
+                            type: "string",
+                            description: "New type for the test case",
+                        },
+                        status: {
+                            type: "string",
+                            description: "New status for the test case",
+                        },
+                        priority: {
+                            type: "string",
+                            description: "New priority for the test case",
+                        },
+                        estimatedDuration: {
+                            type: "number",
+                            description: "New estimated duration in minutes",
+                        },
+                        testData: {
+                            type: "string",
+                            description: "New test data as JSON string",
+                        },
+                        labels: {
+                            type: "array",
+                            items: { type: "string" },
+                            description: "New array of label names",
+                        },
+                        projectId: {
+                            type: "string",
+                            description: "Optional project ID (UUID). If not provided, uses the active project set via 'set_active_project'. " +
+                                "If no active project is set, the tool will return an error with instructions on how to set one.",
+                        },
+                    },
+                    required: ["testCaseId"],
+                },
+            },
+            // {
+            //   name: "delete_test_case",
+            //   description:
+            //     "Delete a test case by ID. This action cannot be undone.",
+            //   inputSchema: {
+            //     type: "object",
+            //     properties: {
+            //       testCaseId: {
+            //         type: "string",
+            //         description: "ID of the test case to delete (required)",
+            //       },
+            //       projectId: {
+            //         type: "string",
+            //         description:
+            //           "Optional project ID. If not provided, uses the configured project ID.",
+            //       },
+            //     },
+            //     required: ["testCaseId"],
+            //   },
+            // },
+            // {
+            //   name: "clone_test_case",
+            //   description:
+            //     "Clone one or more test cases to a target module. Can clone a single test case or multiple test cases at once.",
+            //   inputSchema: {
+            //     type: "object",
+            //     properties: {
+            //       testCaseId: {
+            //         type: "string",
+            //         description:
+            //           "ID of the test case to clone (use this for single clone)",
+            //       },
+            //       testCaseIds: {
+            //         type: "array",
+            //         items: { type: "string" },
+            //         description:
+            //           "Array of test case IDs to clone (use this for bulk clone)",
+            //       },
+            //       targetModuleId: {
+            //         type: "string",
+            //         description:
+            //           "ID of the target module/component/subcomponent where the cloned test case(s) will be created (required)",
+            //       },
+            //       projectId: {
+            //         type: "string",
+            //         description:
+            //           "Optional project ID. If not provided, uses the configured project ID.",
+            //       },
+            //     },
+            //     required: ["targetModuleId"],
+            //   },
+            // },
+            // {
+            //   name: "move_test_case",
+            //   description:
+            //     "Move a test case from one module to another module, component, or subcomponent",
+            //   inputSchema: {
+            //     type: "object",
+            //     properties: {
+            //       testCaseId: {
+            //         type: "string",
+            //         description: "ID of the test case to move (required)",
+            //       },
+            //       targetModuleId: {
+            //         type: "string",
+            //         description:
+            //           "ID of the target module/component/subcomponent where the test case will be moved (required)",
+            //       },
+            //       projectId: {
+            //         type: "string",
+            //         description:
+            //           "Optional project ID. If not provided, uses the configured project ID.",
+            //       },
+            //     },
+            //     required: ["testCaseId", "targetModuleId"],
+            //   },
+            // },
+            // {
+            //   name: "bulk_create_test_cases",
+            //   description:
+            //     "Create multiple test cases at once. Useful for importing or creating many test cases efficiently.",
+            //   inputSchema: {
+            //     type: "object",
+            //     properties: {
+            //       testCases: {
+            //         type: "array",
+            //         items: {
+            //           type: "object",
+            //           properties: {
+            //             title: { type: "string" },
+            //             description: { type: "string" },
+            //             moduleId: { type: "string" },
+            //             type: { type: "string" },
+            //             status: { type: "string" },
+            //             priority: { type: "string" },
+            //             estimatedDuration: { type: "number" },
+            //             testData: { type: "string" },
+            //           },
+            //           required: ["title", "moduleId"],
+            //         },
+            //         description: "Array of test case objects to create",
+            //       },
+            //       projectId: {
+            //         type: "string",
+            //         description:
+            //           "Optional project ID. If not provided, uses the configured project ID.",
+            //       },
+            //     },
+            //     required: ["testCases"],
+            //   },
+            // },
+        ];
+    }
+    handles(name) {
+        return [
+            "list_test_cases",
+            "get_test_case",
+            "get_execution_history",
+            "get_execution_plan",
+            "create_test_case",
+            "update_test_case",
+            // "delete_test_case",
+            // "clone_test_case",
+            // "move_test_case",
+            // "bulk_create_test_cases",
+        ].includes(name);
+    }
+    async handle(name, args) {
+        switch (name) {
+            case "list_test_cases":
+                return await this.listTestCases(args);
+            case "get_test_case":
+                return await this.getTestCase(args);
+            case "get_execution_history":
+                return await this.getExecutionHistory(args);
+            case "get_execution_plan":
+                return await this.getExecutionPlan(args);
+            case "create_test_case":
+                return await this.createTestCase(args);
+            case "update_test_case":
+                return await this.updateTestCase(args);
+            // case "delete_test_case":
+            //   return await this.deleteTestCase(args);
+            // case "clone_test_case":
+            //   return await this.cloneTestCase(args);
+            // case "move_test_case":
+            //   return await this.moveTestCase(args);
+            // case "bulk_create_test_cases":
+            //   return await this.bulkCreateTestCases(args);
+            default:
+                throw new Error(`Unknown test case tool: ${name}`);
+        }
+    }
+    async listTestCases(args) {
+        const { query, page = 1, pageSize = 25, moduleId = 'all', sortField, sortOrder, timezone, projectId: argProjectId, } = args;
+        const projectId = this.projectContext.resolveProjectId(args, "list_test_cases");
+        let normalizedQuery = null;
+        if (query !== undefined && query !== null && typeof query === 'string') {
+            const trimmed = query.trim();
+            normalizedQuery = trimmed.length > 0 ? trimmed : null;
+        }
+        const normalizedModuleId = moduleId === "default" ? "all" : (moduleId || "all");
+        const body = {
+            query: normalizedQuery,
+            page: Number(page) || 1,
+            pageSize: Number(pageSize) || 25,
+            moduleId: normalizedModuleId,
+        };
+        if (sortField !== undefined && sortField !== null) {
+            body.sortField = sortField;
+        }
+        if (sortOrder !== undefined && sortOrder !== null) {
+            body.sortOrder = sortOrder;
+        }
+        if (timezone !== undefined && timezone !== null) {
+            body.timezone = timezone;
+        }
+        try {
+            const response = await this.apiClient.post(`${projectId}/testcase/testcase-search`, body);
+            return jsonResponse({
+                success: response.success,
+                message: response.message,
+                data: response.data,
+            });
+        }
+        catch (error) {
+            // Enhanced error handling - the API client interceptor transforms errors
+            // but we can still access original axios error if available
+            const axiosError = error.response || error.request;
+            const errorData = axiosError?.data || {};
+            // Build detailed error message
+            let errorMessage = error.message || "Unknown error";
+            // If we have validation errors, include them
+            if (errorData.errors && Array.isArray(errorData.errors)) {
+                const validationErrors = errorData.errors
+                    .map((err) => `${err.field || err.path?.join('.')}: ${err.message}`)
+                    .join('\n');
+                errorMessage = `${errorData.message || errorMessage}\nValidation errors:\n${validationErrors}`;
+            }
+            else if (errorData.message) {
+                errorMessage = errorData.message;
+            }
+            // Include request body for debugging
+            errorMessage += `\n\nRequest body: ${JSON.stringify(body, null, 2)}`;
+            throw new Error(`Failed to list test cases: ${errorMessage}`);
+        }
+    }
+    async getTestCase(args) {
+        const { testCaseId } = args;
+        const projectId = this.projectContext.resolveProjectId(args, "get_test_case");
+        if (!testCaseId) {
+            throw new Error("Test case ID is required");
+        }
+        const response = await this.apiClient.get(`${projectId}/testcase/${testCaseId}`);
+        return jsonResponse({
+            success: response.success,
+            message: response.message,
+            data: response.data,
+        });
+    }
+    /**
+     * Resolve label names to IDs by fetching existing labels and creating missing ones.
+     * Returns an array of label objects with only the 'id' field, as expected by the backend.
+     */
+    async resolveLabels(projectId, labels) {
+        if (!labels || labels.length === 0) {
+            return [];
+        }
+        // Fetch all existing labels for the project
+        const existingLabelsResponse = await this.apiClient.get(`${projectId}/labels/getAll`);
+        if (!existingLabelsResponse.success || !existingLabelsResponse.data) {
+            throw new Error("Failed to fetch existing labels");
+        }
+        // Create a map of label name -> label ID (case-insensitive)
+        const labelMap = new Map();
+        existingLabelsResponse.data.forEach((label) => {
+            labelMap.set(label.name.toLowerCase().trim(), label.id);
+        });
+        const resolvedLabels = [];
+        for (const label of labels) {
+            let labelId;
+            if (typeof label === "string") {
+                // Label is a string (name)
+                const normalizedName = label.toLowerCase().trim();
+                labelId = labelMap.get(normalizedName);
+                // If label doesn't exist, create it
+                if (!labelId) {
+                    try {
+                        const createResponse = await this.apiClient.post(`${projectId}/labels/save`, {
+                            labelName: label.trim(),
+                        });
+                        if (createResponse.success && createResponse.data) {
+                            labelId = createResponse.data.id;
+                            // Update the map for potential subsequent uses in the same batch
+                            labelMap.set(normalizedName, labelId);
+                        }
+                        else {
+                            throw new Error(`Failed to create label: ${label}`);
+                        }
+                    }
+                    catch (error) {
+                        throw new Error(`Failed to create label "${label}": ${error.message}`);
+                    }
+                }
+            }
+            else if (label.id) {
+                // Label already has an ID - use it directly
+                labelId = label.id;
+            }
+            else if (label.name) {
+                // Label has a name but no ID
+                const normalizedName = label.name.toLowerCase().trim();
+                labelId = labelMap.get(normalizedName);
+                // If label doesn't exist, create it
+                if (!labelId) {
+                    try {
+                        const createResponse = await this.apiClient.post(`${projectId}/labels/save`, {
+                            labelName: label.name.trim(),
+                        });
+                        if (createResponse.success && createResponse.data) {
+                            labelId = createResponse.data.id;
+                            labelMap.set(normalizedName, labelId);
+                        }
+                        else {
+                            throw new Error(`Failed to create label: ${label.name}`);
+                        }
+                    }
+                    catch (error) {
+                        throw new Error(`Failed to create label "${label.name}": ${error.message}`);
+                    }
+                }
+            }
+            if (labelId) {
+                resolvedLabels.push({ id: labelId });
+            }
+        }
+        return resolvedLabels;
+    }
+    async getExecutionHistory(args) {
+        const projectId = this.projectContext.resolveProjectId(args, "get_execution_history");
+        const { testCaseId, page = 1, pageSize = 25 } = args;
+        if (!testCaseId) {
+            throw new Error("Test case ID is required");
+        }
+        const response = await this.apiClient.get(`${projectId}/testcase/fetchExecutionHistory/${testCaseId}`, {
+            params: { page, pageSize },
+        });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        success: response.success,
+                        message: response.message,
+                        data: response.data,
+                    }, null, 2),
+                },
+            ],
+        };
+    }
+    async getExecutionPlan(args) {
+        const projectId = this.projectContext.resolveProjectId(args, "get_execution_plan");
+        const { testCaseId } = args;
+        if (!testCaseId) {
+            throw new Error("Test case ID is required");
+        }
+        try {
+            const response = await this.apiClient.get(`${projectId}/auto-execution/execution-records/${testCaseId}`);
+            const record = response?.data ?? null;
+            const plan = record?.plan ?? null;
+            const stepsCount = Array.isArray(plan?.steps) ? plan.steps.length : 0;
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({
+                            success: response?.success ?? true,
+                            message: record
+                                ? stepsCount > 0
+                                    ? "Execution plan fetched successfully."
+                                    : "Execution record exists but has no steps."
+                                : "No automation plan saved for this test case.",
+                            data: {
+                                executionRecordId: record?.id,
+                                testCaseId: record?.testcase_id ?? testCaseId,
+                                plan: plan ?? null,
+                                stepsCount,
+                                created_at: record?.created_at,
+                                updated_at: record?.updated_at,
+                                created_by: record?.created_by,
+                                updated_by: record?.updated_by,
+                            },
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (err) {
+            const notFound = err?.message?.includes("not found") ||
+                err?.response?.status === 404;
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({
+                            success: false,
+                            message: notFound
+                                ? "No automation plan saved for this test case."
+                                : err?.message ?? "Failed to fetch execution plan.",
+                            data: {
+                                testCaseId,
+                                plan: null,
+                                stepsCount: 0,
+                            },
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
+    }
+    async createTestCase(args) {
+        const { title, description, moduleId, type, status, priority, estimatedDuration, testData, labels, } = args;
+        const projectId = this.projectContext.resolveProjectId(args, "create_test_case");
+        if (!title) {
+            throw new Error("Test case title is required");
+        }
+        if (!moduleId) {
+            throw new Error("Module ID is required");
+        }
+        // Get user ID for generated_by and updated_by (required by backend)
+        const userId = this.apiClient.getUserId();
+        if (!userId) {
+            throw new Error("User ID not available. Please login first.");
+        }
+        const testCaseData = {
+            title: title.trim(),
+            module_id: moduleId,
+            description: description || "", // Default to empty string
+            type: type || "Functional Test", // Default type
+            status: status || "New", // Default status per OpenAPI spec
+            priority: priority || "Normal", // Default priority
+            generated_by: userId, // Required by database model
+            updated_by: userId, // Required by database model
+        };
+        if (estimatedDuration !== undefined) {
+            testCaseData.estimated_duration = estimatedDuration;
+        }
+        else {
+            testCaseData.estimated_duration = 15; // Default duration
+        }
+        if (testData) {
+            try {
+                testCaseData.testdata = typeof testData === "string" ? JSON.parse(testData) : testData;
+            }
+            catch {
+                testCaseData.testdata = testData;
+            }
+        }
+        if (labels && Array.isArray(labels)) {
+            // Resolve label names to IDs (fetch existing, create missing)
+            const resolvedLabels = await this.resolveLabels(projectId, labels);
+            testCaseData.labels = resolvedLabels;
+        }
+        try {
+            const response = await this.apiClient.post(`${projectId}/testcase/create`, testCaseData);
+            return jsonResponse({
+                success: response.success,
+                message: response.message,
+                data: response.data,
+            });
+        }
+        catch (error) {
+            // Provide more detailed error information
+            const errorMessage = error.message || "Error creating test case";
+            throw new Error(`Failed to create test case: ${errorMessage}`);
+        }
+    }
+    async updateTestCase(args) {
+        const { testCaseId, title, description, type, status, priority, estimatedDuration, testData, labels, } = args;
+        const projectId = this.projectContext.resolveProjectId(args, "update_test_case");
+        if (!testCaseId) {
+            throw new Error("Test case ID is required");
+        }
+        // Fetch current test case to preserve existing values for fields not being updated
+        // The backend assigns all fields directly, so we need to include existing values
+        let currentTestCase = null;
+        try {
+            const response = await this.apiClient.get(`${projectId}/testcase/${testCaseId}`);
+            currentTestCase = response.data;
+        }
+        catch (error) {
+            // If we can't fetch the current test case, continue without it
+            // The backend will handle missing fields
+        }
+        const updateData = {};
+        // Only include fields that are being updated
+        if (title !== undefined)
+            updateData.title = title;
+        if (description !== undefined)
+            updateData.description = description || "";
+        if (type !== undefined)
+            updateData.type = type;
+        if (status !== undefined)
+            updateData.status = status;
+        if (priority !== undefined)
+            updateData.priority = priority;
+        if (estimatedDuration !== undefined)
+            updateData.estimated_duration = estimatedDuration;
+        if (testData !== undefined) {
+            try {
+                updateData.testdata =
+                    typeof testData === "string" ? JSON.parse(testData) : testData;
+            }
+            catch {
+                updateData.testdata = testData;
+            }
+        }
+        if (labels !== undefined) {
+            // Resolve label names to IDs (fetch existing, create missing)
+            const resolvedLabels = await this.resolveLabels(projectId, labels);
+            updateData.labels = resolvedLabels;
+        }
+        if (Object.keys(updateData).length === 0) {
+            throw new Error("At least one field must be provided to update");
+        }
+        // Add updated_by field from the logged-in user (required by backend)
+        const userId = this.apiClient.getUserId();
+        if (!userId) {
+            throw new Error("User ID not available. Please login first.");
+        }
+        updateData.updated_by = userId;
+        const response = await this.apiClient.put(`${projectId}/testcase/${testCaseId}`, updateData);
+        return jsonResponse({
+            success: response.success,
+            message: response.message,
+            data: response.data,
+        });
+    }
+    // private async deleteTestCase(args: any) {
+    //   const { testCaseId, projectId: argProjectId } = args;
+    //   const projectId = argProjectId || this.apiClient["projectId"];
+    //   if (!testCaseId) {
+    //     throw new Error("Test case ID is required");
+    //   }
+    //   if (!projectId) {
+    //     throw new Error(
+    //       "Project ID is required. Either call 'set_active_project' or provide 'projectId' in this call."
+    //     );
+    //   }
+    //   // Backend expects ids as an array in the request body
+    //   const response = await this.apiClient.delete<DeleteTestCaseResponse>(
+    //     `${projectId}/testcase/delete`,
+    //     {
+    //       data: { ids: [testCaseId] },
+    //       headers: {
+    //         "Content-Type": "application/json",
+    //       },
+    //     }
+    //   );
+    //   return {
+    //     content: [
+    //       {
+    //         type: "text",
+    //         text: JSON.stringify(
+    //           {
+    //             success: response.success,
+    //             message: response.message,
+    //             data: response.data,
+    //           },
+    //           null,
+    //           2
+    //         ),
+    //       },
+    //     ],
+    //   };
+    // }
+    async cloneTestCase(args) {
+        const { testCaseId, testCaseIds, targetModuleId } = args;
+        const projectId = this.projectContext.resolveProjectId(args, "clone_test_case");
+        if (!targetModuleId) {
+            throw new Error("Target module ID is required");
+        }
+        if (!testCaseId && (!testCaseIds || testCaseIds.length === 0)) {
+            throw new Error("Either testCaseId or testCaseIds array is required");
+        }
+        if (!projectId) {
+            throw new Error("Project ID is required. Provide it as an argument or set QA_PATH_PROJECT_ID.");
+        }
+        const cloneData = {
+            targetModuleId,
+        };
+        if (testCaseId) {
+            cloneData.testCaseId = testCaseId;
+        }
+        if (testCaseIds) {
+            cloneData.testCaseIds = testCaseIds;
+        }
+        const response = await this.apiClient.post(`${projectId}/testcase/clone`, cloneData);
+        return jsonResponse({
+            success: response.success,
+            message: response.message,
+            data: response.data,
+        });
+    }
+    async moveTestCase(args) {
+        const { testCaseId, targetModuleId } = args;
+        const projectId = this.projectContext.resolveProjectId(args, "move_test_case");
+        if (!testCaseId) {
+            throw new Error("Test case ID is required");
+        }
+        if (!targetModuleId) {
+            throw new Error("Target module ID is required");
+        }
+        const response = await this.apiClient.post(`${projectId}/testcase/move`, {
+            testCaseId,
+            targetModuleId,
+        });
+        return jsonResponse({
+            success: response.success,
+            message: response.message,
+            data: response.data,
+        });
+    }
+    async bulkCreateTestCases(args) {
+        const { testCases } = args;
+        const projectId = this.projectContext.resolveProjectId(args, "bulk_create_test_cases");
+        if (!testCases || !Array.isArray(testCases) || testCases.length === 0) {
+            throw new Error("testCases array is required and must not be empty");
+        }
+        // Transform the test cases to match the API format
+        // Backend expects "Module" (capital M) for bulk create validation
+        const transformedTestCases = testCases.map((tc) => ({
+            title: tc.title,
+            description: tc.description || "",
+            Module: tc.moduleId, // Backend validation expects "Module" (capital M)
+            type: tc.type || "Functional Test",
+            status: tc.status || "New",
+            priority: tc.priority || "Normal",
+            estimated_duration: tc.estimatedDuration || 15,
+            testdata: tc.testData
+                ? typeof tc.testData === "string"
+                    ? JSON.parse(tc.testData)
+                    : tc.testData
+                : null,
+        }));
+        const response = await this.apiClient.post(`${projectId}/testcase/bulkcreate`, {
+            testCases: transformedTestCases,
+        });
+        return jsonResponse({
+            success: response.success,
+            message: response.message,
+            data: response.data,
+        });
+    }
+}
+//# sourceMappingURL=testcase-tools.js.map