imperial-mcp-qase 1.0.0

package/src/tools/defects.ts

@@ -0,0 +1,218 @@
+import { z } from "zod";
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { QaseClient, QaseApiError } from "../client.js";
+
+// Zod schemas for validation
+const ListDefectsSchema = {
+  project_code: z.string().describe("Qase project code (e.g., 'DEMO', 'BPJS')"),
+  limit: z.number().optional().describe("Maximum number of results (default: 100)"),
+  offset: z.number().optional().describe("Offset for pagination"),
+  status: z.string().optional().describe("Filter by status ('open', 'resolved', 'in_progress', 'invalid')"),
+  severity: z.array(z.number()).optional().describe("Filter by severity (0=not set, 1=blocker, 2=critical, 3=major, 4=normal, 5=minor, 6=trivial)"),
+};
+
+const GetDefectSchema = {
+  project_code: z.string().describe("Qase project code (e.g., 'DEMO', 'BPJS')"),
+  defect_id: z.number().describe("Defect ID"),
+};
+
+const CreateDefectSchema = {
+  project_code: z.string().describe("Qase project code (e.g., 'DEMO', 'BPJS')"),
+  title: z.string().describe("Defect title"),
+  actual_result: z.string().describe("Actual result / defect description"),
+  severity: z.number().optional().describe("Severity (0=not set, 1=blocker, 2=critical, 3=major, 4=normal, 5=minor, 6=trivial)"),
+  milestone_id: z.number().optional().describe("Associated milestone ID"),
+  attachments: z.array(z.string()).optional().describe("Attachment hashes (from uploaded files)"),
+  tags: z.array(z.string()).optional().describe("Tags for the defect"),
+};
+
+const UpdateDefectSchema = {
+  project_code: z.string().describe("Qase project code (e.g., 'DEMO', 'BPJS')"),
+  defect_id: z.number().describe("Defect ID to update"),
+  title: z.string().optional().describe("Updated defect title"),
+  actual_result: z.string().optional().describe("Updated actual result / description"),
+  severity: z.number().optional().describe("Updated severity"),
+  status: z.string().optional().describe("Updated status ('open', 'resolved', 'in_progress', 'invalid')"),
+  milestone_id: z.number().optional().describe("Updated milestone ID"),
+  attachments: z.array(z.string()).optional().describe("Updated attachment hashes"),
+  tags: z.array(z.string()).optional().describe("Updated tags"),
+};
+
+const ResolveDefectSchema = {
+  project_code: z.string().describe("Qase project code (e.g., 'DEMO', 'BPJS')"),
+  defect_id: z.number().describe("Defect ID to resolve"),
+};
+
+const DeleteDefectSchema = {
+  project_code: z.string().describe("Qase project code (e.g., 'DEMO', 'BPJS')"),
+  defect_id: z.number().describe("Defect ID to delete"),
+};
+
+function formatError(error: unknown): string {
+  if (error instanceof QaseApiError) {
+    let message = `Qase API Error (${error.statusCode}): ${error.message}`;
+    if (error.errorFields) {
+      message += `\nField errors: ${JSON.stringify(error.errorFields, null, 2)}`;
+    }
+    return message;
+  }
+  if (error instanceof Error) {
+    return `Error: ${error.message}`;
+  }
+  return `Unknown error: ${String(error)}`;
+}
+
+export function registerDefectTools(server: McpServer, client: QaseClient): void {
+  // List defects
+  server.tool(
+    "qase_list_defects",
+    "List defects in a Qase project with optional filtering",
+    ListDefectsSchema,
+    async (args) => {
+      try {
+        const { project_code, ...filters } = args;
+        const response = await client.listDefects(project_code, filters);
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(response, null, 2),
+            },
+          ],
+        };
+      } catch (error) {
+        return {
+          content: [{ type: "text", text: formatError(error) }],
+          isError: true,
+        };
+      }
+    }
+  );
+
+  // Get single defect
+  server.tool(
+    "qase_get_defect",
+    "Get a single defect by ID from a Qase project",
+    GetDefectSchema,
+    async (args) => {
+      try {
+        const response = await client.getDefect(args.project_code, args.defect_id);
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(response, null, 2),
+            },
+          ],
+        };
+      } catch (error) {
+        return {
+          content: [{ type: "text", text: formatError(error) }],
+          isError: true,
+        };
+      }
+    }
+  );
+
+  // Create defect
+  server.tool(
+    "qase_create_defect",
+    "Create a new defect in a Qase project",
+    CreateDefectSchema,
+    async (args) => {
+      try {
+        const { project_code, ...defectData } = args;
+        const response = await client.createDefect(project_code, defectData);
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(response, null, 2),
+            },
+          ],
+        };
+      } catch (error) {
+        return {
+          content: [{ type: "text", text: formatError(error) }],
+          isError: true,
+        };
+      }
+    }
+  );
+
+  // Update defect
+  server.tool(
+    "qase_update_defect",
+    "Update an existing defect in a Qase project",
+    UpdateDefectSchema,
+    async (args) => {
+      try {
+        const { project_code, defect_id, ...updateData } = args;
+        const response = await client.updateDefect(project_code, defect_id, updateData);
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(response, null, 2),
+            },
+          ],
+        };
+      } catch (error) {
+        return {
+          content: [{ type: "text", text: formatError(error) }],
+          isError: true,
+        };
+      }
+    }
+  );
+
+  // Resolve defect
+  server.tool(
+    "qase_resolve_defect",
+    "Mark a defect as resolved in a Qase project",
+    ResolveDefectSchema,
+    async (args) => {
+      try {
+        const response = await client.resolveDefect(args.project_code, args.defect_id);
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(response, null, 2),
+            },
+          ],
+        };
+      } catch (error) {
+        return {
+          content: [{ type: "text", text: formatError(error) }],
+          isError: true,
+        };
+      }
+    }
+  );
+
+  // Delete defect
+  server.tool(
+    "qase_delete_defect",
+    "Delete a defect from a Qase project",
+    DeleteDefectSchema,
+    async (args) => {
+      try {
+        const response = await client.deleteDefect(args.project_code, args.defect_id);
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(response, null, 2),
+            },
+          ],
+        };
+      } catch (error) {
+        return {
+          content: [{ type: "text", text: formatError(error) }],
+          isError: true,
+        };
+      }
+    }
+  );
+}

package/src/tools/projects.ts

@@ -0,0 +1,49 @@
+import { z } from "zod";
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { QaseClient, QaseApiError } from "../client.js";
+
+const ListProjectsSchema = {
+  limit: z.number().optional().describe("Maximum number of results (default: 100)"),
+  offset: z.number().optional().describe("Offset for pagination"),
+};
+
+function formatError(error: unknown): string {
+  if (error instanceof QaseApiError) {
+    let message = `Qase API Error (${error.statusCode}): ${error.message}`;
+    if (error.errorFields) {
+      message += `\nField errors: ${JSON.stringify(error.errorFields, null, 2)}`;
+    }
+    return message;
+  }
+  if (error instanceof Error) {
+    return `Error: ${error.message}`;
+  }
+  return `Unknown error: ${String(error)}`;
+}
+
+export function registerProjectTools(server: McpServer, client: QaseClient): void {
+  // List all projects
+  server.tool(
+    "qase_list_projects",
+    "List all Qase projects accessible with the current API token",
+    ListProjectsSchema,
+    async (args) => {
+      try {
+        const response = await client.listProjects(args);
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(response, null, 2),
+            },
+          ],
+        };
+      } catch (error) {
+        return {
+          content: [{ type: "text", text: formatError(error) }],
+          isError: true,
+        };
+      }
+    }
+  );
+}

package/src/tools/results.ts

@@ -0,0 +1,204 @@
+import { z } from "zod";
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { QaseClient, QaseApiError } from "../client.js";
+
+// Zod schemas for validation
+const ListResultsSchema = {
+  project_code: z.string().describe("Qase project code (e.g., 'DEMO', 'BPJS')"),
+  run_id: z.number().describe("Test run ID to list results from"),
+};
+
+const GetResultSchema = {
+  project_code: z.string().describe("Qase project code (e.g., 'DEMO', 'BPJS')"),
+  run_id: z.number().describe("Test run ID"),
+  hash: z.string().describe("Result hash identifier"),
+};
+
+const ResultStepSchema = z.object({
+  position: z.number().describe("Step position (order)"),
+  status: z.enum(["passed", "failed", "blocked", "skipped"]).describe("Step status"),
+  comment: z.string().optional().describe("Step comment"),
+  attachments: z.array(z.string()).optional().describe("Attachment hashes for this step"),
+});
+
+const CreateResultSchema = {
+  project_code: z.string().describe("Qase project code (e.g., 'DEMO', 'BPJS')"),
+  run_id: z.number().describe("Test run ID to add result to"),
+  case_id: z.number().describe("Test case ID for this result"),
+  status: z.enum(["passed", "failed", "blocked", "skipped", "invalid"]).describe("Test result status"),
+  time_ms: z.number().optional().describe("Time spent in milliseconds"),
+  member_id: z.number().optional().describe("Team member ID who executed the test"),
+  comment: z.string().optional().describe("Result comment"),
+  stacktrace: z.string().optional().describe("Stack trace (for failed tests)"),
+  defect: z.boolean().optional().describe("Whether to create a defect (for failed tests)"),
+  steps: z.array(ResultStepSchema).optional().describe("Individual step results"),
+  attachments: z.array(z.string()).optional().describe("Attachment hashes"),
+};
+
+const CreateResultBulkSchema = {
+  project_code: z.string().describe("Qase project code (e.g., 'DEMO', 'BPJS')"),
+  run_id: z.number().describe("Test run ID to add results to"),
+  results: z.array(z.object({
+    case_id: z.number().describe("Test case ID"),
+    status: z.enum(["passed", "failed", "blocked", "skipped", "invalid"]).describe("Test result status"),
+    time_ms: z.number().optional().describe("Time spent in milliseconds"),
+    member_id: z.number().optional().describe("Team member ID"),
+    comment: z.string().optional().describe("Result comment"),
+    stacktrace: z.string().optional().describe("Stack trace"),
+    defect: z.boolean().optional().describe("Whether to create a defect"),
+    steps: z.array(ResultStepSchema).optional().describe("Step results"),
+    attachments: z.array(z.string()).optional().describe("Attachment hashes"),
+  })).describe("Array of test results to add"),
+};
+
+const DeleteResultSchema = {
+  project_code: z.string().describe("Qase project code (e.g., 'DEMO', 'BPJS')"),
+  run_id: z.number().describe("Test run ID"),
+  hash: z.string().describe("Result hash to delete"),
+};
+
+function formatError(error: unknown): string {
+  if (error instanceof QaseApiError) {
+    let message = `Qase API Error (${error.statusCode}): ${error.message}`;
+    if (error.errorFields) {
+      message += `\nField errors: ${JSON.stringify(error.errorFields, null, 2)}`;
+    }
+    return message;
+  }
+  if (error instanceof Error) {
+    return `Error: ${error.message}`;
+  }
+  return `Unknown error: ${String(error)}`;
+}
+
+export function registerResultTools(server: McpServer, client: QaseClient): void {
+  // List test results
+  server.tool(
+    "qase_list_results",
+    "List test results for a test run in a Qase project",
+    ListResultsSchema,
+    async (args) => {
+      try {
+        const response = await client.listResults(args.project_code, args.run_id);
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(response, null, 2),
+            },
+          ],
+        };
+      } catch (error) {
+        return {
+          content: [{ type: "text", text: formatError(error) }],
+          isError: true,
+        };
+      }
+    }
+  );
+
+  // Get single test result
+  server.tool(
+    "qase_get_result",
+    "Get a single test result by hash from a test run",
+    GetResultSchema,
+    async (args) => {
+      try {
+        const response = await client.getResult(args.project_code, args.run_id, args.hash);
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(response, null, 2),
+            },
+          ],
+        };
+      } catch (error) {
+        return {
+          content: [{ type: "text", text: formatError(error) }],
+          isError: true,
+        };
+      }
+    }
+  );
+
+  // Add test result
+  server.tool(
+    "qase_add_result",
+    "Add a test result to a test run in a Qase project",
+    CreateResultSchema,
+    async (args) => {
+      try {
+        const { project_code, run_id, ...resultData } = args;
+        const response = await client.createResult(project_code, run_id, resultData);
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(response, null, 2),
+            },
+          ],
+        };
+      } catch (error) {
+        return {
+          content: [{ type: "text", text: formatError(error) }],
+          isError: true,
+        };
+      }
+    }
+  );
+
+  // Add bulk test results
+  server.tool(
+    "qase_add_results_bulk",
+    "Add multiple test results to a test run in a Qase project",
+    CreateResultBulkSchema,
+    async (args) => {
+      try {
+        const response = await client.createResultBulk(
+          args.project_code,
+          args.run_id,
+          args.results
+        );
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(response, null, 2),
+            },
+          ],
+        };
+      } catch (error) {
+        return {
+          content: [{ type: "text", text: formatError(error) }],
+          isError: true,
+        };
+      }
+    }
+  );
+
+  // Delete test result
+  server.tool(
+    "qase_delete_result",
+    "Delete a test result from a test run",
+    DeleteResultSchema,
+    async (args) => {
+      try {
+        const response = await client.deleteResult(args.project_code, args.run_id, args.hash);
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(response, null, 2),
+            },
+          ],
+        };
+      } catch (error) {
+        return {
+          content: [{ type: "text", text: formatError(error) }],
+          isError: true,
+        };
+      }
+    }
+  );
+}

package/src/tools/runs.ts

@@ -0,0 +1,182 @@
+import { z } from "zod";
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { QaseClient, QaseApiError } from "../client.js";
+
+// Zod schemas for validation
+const ListRunsSchema = {
+  project_code: z.string().describe("Qase project code (e.g., 'DEMO', 'BPJS')"),
+  limit: z.number().optional().describe("Maximum number of results (default: 100)"),
+  offset: z.number().optional().describe("Offset for pagination"),
+  status: z.string().optional().describe("Filter by status ('active', 'complete', 'abort')"),
+  include: z.string().optional().describe("Include additional data (e.g., 'cases')"),
+};
+
+const GetRunSchema = {
+  project_code: z.string().describe("Qase project code (e.g., 'DEMO', 'BPJS')"),
+  run_id: z.number().describe("Test run ID"),
+};
+
+const CreateRunSchema = {
+  project_code: z.string().describe("Qase project code (e.g., 'DEMO', 'BPJS')"),
+  title: z.string().describe("Test run title"),
+  description: z.string().optional().describe("Test run description"),
+  environment_id: z.number().optional().describe("Environment ID"),
+  milestone_id: z.number().optional().describe("Associated milestone ID"),
+  plan_id: z.number().optional().describe("Test plan ID to use"),
+  cases: z.array(z.number()).optional().describe("Array of test case IDs to include"),
+  is_autotest: z.boolean().optional().describe("Mark as automated test run"),
+  tags: z.array(z.string()).optional().describe("Tags for the test run"),
+};
+
+const CompleteRunSchema = {
+  project_code: z.string().describe("Qase project code (e.g., 'DEMO', 'BPJS')"),
+  run_id: z.number().describe("Test run ID to complete"),
+};
+
+const DeleteRunSchema = {
+  project_code: z.string().describe("Qase project code (e.g., 'DEMO', 'BPJS')"),
+  run_id: z.number().describe("Test run ID to delete"),
+};
+
+function formatError(error: unknown): string {
+  if (error instanceof QaseApiError) {
+    let message = `Qase API Error (${error.statusCode}): ${error.message}`;
+    if (error.errorFields) {
+      message += `\nField errors: ${JSON.stringify(error.errorFields, null, 2)}`;
+    }
+    return message;
+  }
+  if (error instanceof Error) {
+    return `Error: ${error.message}`;
+  }
+  return `Unknown error: ${String(error)}`;
+}
+
+export function registerRunTools(server: McpServer, client: QaseClient): void {
+  // List test runs
+  server.tool(
+    "qase_list_runs",
+    "List test runs in a Qase project with optional filtering",
+    ListRunsSchema,
+    async (args) => {
+      try {
+        const { project_code, ...filters } = args;
+        const response = await client.listRuns(project_code, filters);
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(response, null, 2),
+            },
+          ],
+        };
+      } catch (error) {
+        return {
+          content: [{ type: "text", text: formatError(error) }],
+          isError: true,
+        };
+      }
+    }
+  );
+
+  // Get single test run
+  server.tool(
+    "qase_get_run",
+    "Get a single test run by ID from a Qase project",
+    GetRunSchema,
+    async (args) => {
+      try {
+        const response = await client.getRun(args.project_code, args.run_id);
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(response, null, 2),
+            },
+          ],
+        };
+      } catch (error) {
+        return {
+          content: [{ type: "text", text: formatError(error) }],
+          isError: true,
+        };
+      }
+    }
+  );
+
+  // Create test run
+  server.tool(
+    "qase_create_run",
+    "Create a new test run in a Qase project",
+    CreateRunSchema,
+    async (args) => {
+      try {
+        const { project_code, ...runData } = args;
+        const response = await client.createRun(project_code, runData);
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(response, null, 2),
+            },
+          ],
+        };
+      } catch (error) {
+        return {
+          content: [{ type: "text", text: formatError(error) }],
+          isError: true,
+        };
+      }
+    }
+  );
+
+  // Complete test run
+  server.tool(
+    "qase_complete_run",
+    "Complete/finish a test run in a Qase project",
+    CompleteRunSchema,
+    async (args) => {
+      try {
+        const response = await client.completeRun(args.project_code, args.run_id);
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(response, null, 2),
+            },
+          ],
+        };
+      } catch (error) {
+        return {
+          content: [{ type: "text", text: formatError(error) }],
+          isError: true,
+        };
+      }
+    }
+  );
+
+  // Delete test run
+  server.tool(
+    "qase_delete_run",
+    "Delete a test run from a Qase project",
+    DeleteRunSchema,
+    async (args) => {
+      try {
+        const response = await client.deleteRun(args.project_code, args.run_id);
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(response, null, 2),
+            },
+          ],
+        };
+      } catch (error) {
+        return {
+          content: [{ type: "text", text: formatError(error) }],
+          isError: true,
+        };
+      }
+    }
+  );
+}