@smartbear/mcp 0.24.0 → 0.25.1

package/dist/qtm4j/tool/requirement/link-testcases.js

@@ -0,0 +1,107 @@
+import { Tool, ToolError } from "../../../common/tools.js";
+import { TOOLSETS, TOOL_NAMES, ENDPOINTS } from "../../config/constants.js";
+import { ResolverKeys } from "../../config/field-resolution.types.js";
+import { RequirementTestCaseLinkResponse, LinkTestCasesToRequirementBody } from "../../schema/requirements.schema.js";
+class LinkTestCasesToRequirement extends Tool {
+  specification = {
+    title: TOOL_NAMES.LINK_TESTCASES_TO_REQUIREMENT.TITLE,
+    summary: TOOL_NAMES.LINK_TESTCASES_TO_REQUIREMENT.SUMMARY,
+    readOnly: false,
+    idempotent: false,
+    toolset: TOOLSETS.REQUIREMENTS,
+    inputSchema: LinkTestCasesToRequirementBody,
+    outputSchema: RequirementTestCaseLinkResponse,
+    purpose: "Link test cases to a Jira requirement in QTM4J using the requirement's human-readable key. Test cases can be specified by their keys (e.g. 'SCRUM-TC-1'), which are resolved to internal IDs and latest versions automatically. Alternatively, use a filter object to select test cases by criteria such as status, priority, labels, or folder. The active project ID is injected automatically into the filter. Test cases that cannot be linked are reported in warnings. PREREQUISITE: set_project_context must be called before this tool.",
+    useCases: [
+      "Link specific test cases to a Jira story or bug by requirement key",
+      "Build traceability between Jira requirements and QTM4J test cases",
+      "Link all test cases matching a filter to a requirement",
+      "Associate test cases with a requirement as part of sprint planning"
+    ],
+    examples: [
+      {
+        description: "Link two test cases by key",
+        parameters: {
+          requirementKey: "SCRUM-1",
+          testCaseKeys: ["SCRUM-TC-10", "SCRUM-TC-11"]
+        },
+        expectedOutput: "Test cases linked to requirement SCRUM-1"
+      },
+      {
+        description: "Link test cases matching a filter",
+        parameters: {
+          requirementKey: "SCRUM-1",
+          filter: { priority: ["High"], status: ["To Do"] }
+        },
+        expectedOutput: "Filtered test cases linked to requirement"
+      },
+      {
+        description: "Link test cases in a specific folder",
+        parameters: {
+          requirementKey: "SCRUM-5",
+          filter: { folderId: 42, withChild: true },
+          sort: "key:asc"
+        },
+        expectedOutput: "Folder test cases linked to requirement"
+      }
+    ],
+    hints: [
+      "PREREQUISITE: set_project_context must be called before this tool. NEVER auto-select a project.",
+      "REQUIREMENT KEY FORMAT: '{PROJECT_KEY}-{number}' — e.g. 'SCRUM-1'.",
+      "TEST CASE KEY FORMAT: '{PROJECT_KEY}-TC-{number}' — e.g. 'SCRUM-TC-145'.",
+      "Provide either testCaseKeys or filter — not both.",
+      "projectId in filter is auto-filled from the active project context — do not set it manually.",
+      "filter.excludeRequirementId excludes test cases already linked to that requirement ID.",
+      "If a test case key cannot be resolved, it is reported in warnings and other test cases are still linked."
+    ],
+    outputDescription: "Confirmation with the requirement key and linked: true. Warnings included if any test cases could not be resolved or linked."
+  };
+  handle = async (rawArgs) => {
+    const args = LinkTestCasesToRequirementBody.parse(rawArgs);
+    const fieldResolver = this.client.getResolverRegistry();
+    const context = fieldResolver.requireProjectContext();
+    const warnings = [];
+    const reqMap = await fieldResolver.getResolver(ResolverKeys.SearchableField.REQUIREMENT_KEY_TO_ID).resolveAndReturn(context.projectId, [args.requirementKey]);
+    const reqEntry = reqMap[args.requirementKey];
+    if (!reqEntry) {
+      throw new ToolError(
+        `Requirement '${args.requirementKey}' not found in project '${context.projectKey}'. Verify the key is a valid Jira issue key.`
+      );
+    }
+    const requirementId = Number(reqEntry.id);
+    const body = {};
+    if (args.testCaseKeys?.length) {
+      const uidMap = await fieldResolver.getResolver(ResolverKeys.SearchableField.TEST_CASE_KEY_TO_UID).resolveAndReturn(context.projectId, args.testCaseKeys);
+      const testcases = [];
+      for (const tcKey of args.testCaseKeys) {
+        const resolved = uidMap[tcKey];
+        if (resolved) {
+          testcases.push({
+            id: resolved.uid,
+            versionNo: resolved.latestVersion
+          });
+        } else {
+          warnings.push(
+            `Test case '${tcKey}' could not be resolved and was skipped.`
+          );
+        }
+      }
+      if (testcases.length > 0) body.testcases = testcases;
+    }
+    if (args.filter) {
+      body.filter = { ...args.filter, projectId: context.projectId };
+    }
+    if (args.sort) body.sort = args.sort;
+    await this.client.getApiClient().post(ENDPOINTS.LINK_TESTCASES_TO_REQUIREMENT(requirementId), body);
+    return {
+      structuredContent: RequirementTestCaseLinkResponse.parse({
+        requirementKey: args.requirementKey,
+        linked: true
+      }),
+      content: warnings.length > 0 ? [{ type: "text", text: `Note: ${warnings.join(" | ")}` }] : []
+    };
+  };
+}
+export {
+  LinkTestCasesToRequirement
+};

package/dist/qtm4j/tool/requirement/unlink-testcases.js

@@ -0,0 +1,97 @@
+import { Tool, ToolError } from "../../../common/tools.js";
+import { TOOLSETS, TOOL_NAMES, ENDPOINTS } from "../../config/constants.js";
+import { ResolverKeys } from "../../config/field-resolution.types.js";
+import { RequirementTestCaseLinkResponse, UnlinkTestCasesFromRequirementBody } from "../../schema/requirements.schema.js";
+class UnlinkTestCasesFromRequirement extends Tool {
+  specification = {
+    title: TOOL_NAMES.UNLINK_TESTCASES_FROM_REQUIREMENT.TITLE,
+    summary: TOOL_NAMES.UNLINK_TESTCASES_FROM_REQUIREMENT.SUMMARY,
+    readOnly: false,
+    idempotent: false,
+    toolset: TOOLSETS.REQUIREMENTS,
+    inputSchema: UnlinkTestCasesFromRequirementBody,
+    outputSchema: RequirementTestCaseLinkResponse,
+    purpose: "Unlink test cases from a Jira requirement in QTM4J using the requirement's human-readable key. Test cases can be specified by their keys (e.g. 'SCRUM-TC-1'), which are resolved to internal IDs and latest versions automatically. Alternatively, use a filter object to select test cases to unlink by criteria. The active project ID is injected automatically into the filter. Test cases that cannot be unlinked are reported in warnings. PREREQUISITE: set_project_context must be called before this tool.",
+    useCases: [
+      "Remove specific test cases from a Jira requirement",
+      "Unlink test cases matching a filter from a requirement",
+      "Clean up stale or incorrect test case links on a requirement",
+      "Remove traceability links as part of sprint cleanup"
+    ],
+    examples: [
+      {
+        description: "Unlink specific test cases by key",
+        parameters: {
+          requirementKey: "SCRUM-1",
+          testCaseKeys: ["SCRUM-TC-10", "SCRUM-TC-11"]
+        },
+        expectedOutput: "Test cases unlinked from requirement SCRUM-1"
+      },
+      {
+        description: "Unlink test cases matching a filter",
+        parameters: {
+          requirementKey: "SCRUM-1",
+          filter: { status: ["Done"], labels: ["Deprecated"] }
+        },
+        expectedOutput: "Filtered test cases unlinked from requirement"
+      }
+    ],
+    hints: [
+      "PREREQUISITE: set_project_context must be called before this tool. NEVER auto-select a project.",
+      "REQUIREMENT KEY FORMAT: '{PROJECT_KEY}-{number}' — e.g. 'SCRUM-1'.",
+      "TEST CASE KEY FORMAT: '{PROJECT_KEY}-TC-{number}' — e.g. 'SCRUM-TC-145'.",
+      "Provide either testCaseKeys or filter — not both.",
+      "projectId in filter is auto-filled from the active project context — do not set it manually.",
+      "filter.excludeTestCases can be used to exclude specific test cases when using filter-based unlinking.",
+      "If a test case key cannot be resolved, it is reported in warnings and other test cases are still unlinked."
+    ],
+    outputDescription: "Confirmation with the requirement key and unlinked: true. Warnings included if any test cases could not be resolved or unlinked."
+  };
+  handle = async (rawArgs) => {
+    const args = UnlinkTestCasesFromRequirementBody.parse(rawArgs);
+    const fieldResolver = this.client.getResolverRegistry();
+    const context = fieldResolver.requireProjectContext();
+    const warnings = [];
+    const reqMap = await fieldResolver.getResolver(ResolverKeys.SearchableField.REQUIREMENT_KEY_TO_ID).resolveAndReturn(context.projectId, [args.requirementKey]);
+    const reqEntry = reqMap[args.requirementKey];
+    if (!reqEntry) {
+      throw new ToolError(
+        `Requirement '${args.requirementKey}' not found in project '${context.projectKey}'. Verify the key is a valid Jira issue key.`
+      );
+    }
+    const requirementId = Number(reqEntry.id);
+    const body = {};
+    if (args.testCaseKeys?.length) {
+      const uidMap = await fieldResolver.getResolver(ResolverKeys.SearchableField.TEST_CASE_KEY_TO_UID).resolveAndReturn(context.projectId, args.testCaseKeys);
+      const testcases = [];
+      for (const tcKey of args.testCaseKeys) {
+        const resolved = uidMap[tcKey];
+        if (resolved) {
+          testcases.push({
+            id: resolved.uid,
+            versionNo: resolved.latestVersion
+          });
+        } else {
+          warnings.push(
+            `Test case '${tcKey}' could not be resolved and was skipped.`
+          );
+        }
+      }
+      if (testcases.length > 0) body.testcases = testcases;
+    }
+    if (args.filter) {
+      body.filter = { ...args.filter, projectId: context.projectId };
+    }
+    await this.client.getApiClient().delete(ENDPOINTS.UNLINK_TESTCASES_FROM_REQUIREMENT(requirementId), body);
+    return {
+      structuredContent: RequirementTestCaseLinkResponse.parse({
+        requirementKey: args.requirementKey,
+        unlinked: true
+      }),
+      content: warnings.length > 0 ? [{ type: "text", text: `Note: ${warnings.join(" | ")}` }] : []
+    };
+  };
+}
+export {
+  UnlinkTestCasesFromRequirement
+};

package/dist/qtm4j/tool/test-automation/get-automation-history.js

@@ -1,9 +1,10 @@
 import { Tool } from "../../../common/tools.js";
-import { TOOL_NAMES, ENDPOINTS } from "../../config/constants.js";
+import { TOOL_NAMES, TOOLSETS, ENDPOINTS } from "../../config/constants.js";
 import { GetAutomationHistoryResponse, GetAutomationHistoryBody } from "../../schema/automation.schema.js";
 class GetAutomationHistory extends Tool {
   specification = {
     title: TOOL_NAMES.GET_AUTOMATION_HISTORY.TITLE,
+    toolset: TOOLSETS.TEST_AUTOMATION,
     summary: TOOL_NAMES.GET_AUTOMATION_HISTORY.SUMMARY,
     readOnly: true,
     idempotent: true,

package/dist/qtm4j/tool/test-automation/upload-automation-result.js

@@ -1,12 +1,13 @@
 import { readFile } from "node:fs/promises";
 import { extname } from "node:path";
 import { Tool, ToolError } from "../../../common/tools.js";
-import { TOOL_NAMES, AUTOMATION_RESULT_DIRS, AUTOMATION_LIMITS, ENDPOINTS } from "../../config/constants.js";
+import { TOOL_NAMES, TOOLSETS, AUTOMATION_RESULT_DIRS, AUTOMATION_LIMITS, ENDPOINTS } from "../../config/constants.js";
 import { UploadAutomationResultResponse, UploadAutomationResultBody } from "../../schema/automation.schema.js";
 const SUPPORTED_EXTENSIONS = /* @__PURE__ */ new Set([".xml", ".json", ".zip"]);
 class UploadAutomationResult extends Tool {
   specification = {
     title: TOOL_NAMES.UPLOAD_AUTOMATION_RESULT.TITLE,
+    toolset: TOOLSETS.TEST_AUTOMATION,
     summary: TOOL_NAMES.UPLOAD_AUTOMATION_RESULT.SUMMARY,
     readOnly: false,
     idempotent: false,

package/dist/qtm4j/tool/test-case/create-test-case.js

@@ -1,5 +1,5 @@
 import { Tool } from "../../../common/tools.js";
-import { TOOL_NAMES, ENDPOINTS } from "../../config/constants.js";
+import { TOOL_NAMES, TOOLSETS, ENDPOINTS } from "../../config/constants.js";
 import { ResolverKeys, InputField } from "../../config/field-resolution.types.js";
 import { CreateTestCaseResponse, CreateTestCaseBody } from "../../schema/test-case.schema.js";
 const FIELD_CONFIG = {
@@ -13,6 +13,7 @@ class CreateTestCase extends Tool {
   // ─── Tool Specification ────────────────────────────────────────────────────
   specification = {
     title: TOOL_NAMES.CREATE_TEST_CASE.TITLE,
+    toolset: TOOLSETS.TEST_CASES,
     summary: TOOL_NAMES.CREATE_TEST_CASE.SUMMARY,
     readOnly: false,
     idempotent: false,

package/dist/qtm4j/tool/test-case/get-linked-requirements.js

@@ -0,0 +1,67 @@
+import { Tool, ToolError } from "../../../common/tools.js";
+import { TOOLSETS, TOOL_NAMES, ENDPOINTS } from "../../config/constants.js";
+import { ResolverKeys } from "../../config/field-resolution.types.js";
+import { GetLinkedRequirementsResponse, GetLinkedRequirementsBody } from "../../schema/linked-items.schema.js";
+class GetLinkedRequirements extends Tool {
+  specification = {
+    title: TOOL_NAMES.GET_LINKED_REQUIREMENTS.TITLE,
+    summary: TOOL_NAMES.GET_LINKED_REQUIREMENTS.SUMMARY,
+    readOnly: true,
+    idempotent: true,
+    toolset: TOOLSETS.TEST_CASES,
+    inputSchema: GetLinkedRequirementsBody,
+    outputSchema: GetLinkedRequirementsResponse,
+    purpose: "Retrieve all Jira requirements linked to a specific test case in QTM4J. The test case's human-readable key (e.g. 'SCRUM-TC-145') is resolved to the internal UID automatically. Returns a paginated list of linked requirements with their Jira metadata (key, summary, status, priority, issue type). PREREQUISITE: set_project_context must be called before this tool.",
+    useCases: [
+      "Check which Jira stories or bugs a test case covers",
+      "Audit requirement traceability for a test case",
+      "Retrieve requirement keys to use in other operations",
+      "Verify that the correct requirements are linked to a test case before a release"
+    ],
+    examples: [
+      {
+        description: "Get all requirements linked to a test case",
+        parameters: { key: "SCRUM-TC-145" },
+        expectedOutput: "Paginated list of linked requirements with Jira metadata"
+      },
+      {
+        description: "Get requirements for a specific version",
+        parameters: { key: "SCRUM-TC-85", versionNo: 2, maxResults: 20 },
+        expectedOutput: "Requirements linked to version 2 of the test case"
+      }
+    ],
+    hints: [
+      "PREREQUISITE: set_project_context must be called before this tool. NEVER auto-select a project.",
+      "KEY FORMAT: '{PROJECT_KEY}-TC-{number}' — e.g. 'SCRUM-TC-145'.",
+      "versionNo defaults to the latest version. Use search_test_cases to find available versions.",
+      "Paginate using startAt — increment by maxResults until startAt >= total."
+    ],
+    outputDescription: "Paginated list with total, startAt, maxResults, and data array of linked requirement objects (id, key, summary, status, priority, issueType)."
+  };
+  handle = async (rawArgs) => {
+    const args = GetLinkedRequirementsBody.parse(rawArgs);
+    const fieldResolver = this.client.getResolverRegistry();
+    const context = fieldResolver.requireProjectContext();
+    const uidMap = await fieldResolver.getResolver(ResolverKeys.SearchableField.TEST_CASE_KEY_TO_UID).resolveAndReturn(context.projectId, [args.key]);
+    const entry = uidMap[args.key];
+    if (!entry) {
+      throw new ToolError(
+        `Test case '${args.key}' not found in project '${context.projectKey}'. Verify the key using the search_test_cases tool.`
+      );
+    }
+    const params = {
+      maxResults: args.maxResults,
+      startAt: args.startAt,
+      sort: args.sort,
+      tcVersionNo: args.versionNo
+    };
+    const response = await this.client.getApiClient().get(ENDPOINTS.GET_LINKED_REQUIREMENTS(entry.uid), params);
+    return {
+      structuredContent: GetLinkedRequirementsResponse.parse(response),
+      content: []
+    };
+  };
+}
+export {
+  GetLinkedRequirements
+};

package/dist/qtm4j/tool/test-case/get-test-cases.js

@@ -1,9 +1,10 @@
 import { Tool } from "../../../common/tools.js";
-import { TOOL_NAMES, RESPONSE_FIELDS, ENDPOINTS } from "../../config/constants.js";
+import { TOOL_NAMES, TOOLSETS, RESPONSE_FIELDS, ENDPOINTS } from "../../config/constants.js";
 import { SearchTestCaseResponse, SearchTestCaseBody } from "../../schema/get-test-case.schema.js";
 class GetTestCases extends Tool {
   specification = {
     title: TOOL_NAMES.SEARCH_TEST_CASES.TITLE,
+    toolset: TOOLSETS.TEST_CASES,
     summary: TOOL_NAMES.SEARCH_TEST_CASES.SUMMARY,
     readOnly: true,
     idempotent: true,

package/dist/qtm4j/tool/test-case/get-test-steps.js

@@ -1,10 +1,11 @@
 import { Tool, ToolError } from "../../../common/tools.js";
-import { TOOL_NAMES, RESPONSE_FIELDS, ENDPOINTS } from "../../config/constants.js";
+import { TOOL_NAMES, TOOLSETS, RESPONSE_FIELDS, ENDPOINTS } from "../../config/constants.js";
 import { ResolverKeys } from "../../config/field-resolution.types.js";
 import { GetTestStepsResponse, GetTestStepsBody } from "../../schema/get-test-steps.schema.js";
 class GetTestSteps extends Tool {
   specification = {
     title: TOOL_NAMES.GET_TEST_STEPS.TITLE,
+    toolset: TOOLSETS.TEST_CASES,
     summary: TOOL_NAMES.GET_TEST_STEPS.SUMMARY,
     readOnly: true,
     idempotent: true,

package/dist/qtm4j/tool/test-case/link-requirements.js

@@ -0,0 +1,124 @@
+import zod__default from "zod";
+import { Tool, ToolError } from "../../../common/tools.js";
+import { TOOLSETS, TOOL_NAMES, ENDPOINTS } from "../../config/constants.js";
+import { ResolverKeys } from "../../config/field-resolution.types.js";
+const LinkRequirementsBody = zod__default.object({
+  key: zod__default.string().describe(
+    "Test case key in '{PROJECT_KEY}-TC-{number}' format (e.g., 'SCRUM-TC-145'). Required."
+  ),
+  versionNo: zod__default.number().int().optional().describe("Test case version number. Defaults to the latest version."),
+  requirementKeys: zod__default.array(zod__default.string()).optional().describe(
+    "List of requirement keys to link (e.g., ['SCRUM-1', 'SCRUM-2']). Resolved to internal IDs automatically. Provide this OR filter.jql — not both."
+  ),
+  filter: zod__default.object({
+    jql: zod__default.string().describe(
+      'JQL query to filter requirements to link (e.g., "project = DEMO AND issuetype = Story").'
+    )
+  }).optional().describe(
+    "JQL filter to select requirements to link. Use instead of requirementKeys when filtering by JQL."
+  )
+});
+const LinkRequirementsResponse = zod__default.object({
+  key: zod__default.string(),
+  versionNo: zod__default.number().int(),
+  linked: zod__default.literal(true)
+});
+class LinkRequirements extends Tool {
+  specification = {
+    title: TOOL_NAMES.LINK_REQUIREMENTS.TITLE,
+    summary: TOOL_NAMES.LINK_REQUIREMENTS.SUMMARY,
+    readOnly: false,
+    idempotent: false,
+    toolset: TOOLSETS.TEST_CASES,
+    inputSchema: LinkRequirementsBody,
+    outputSchema: LinkRequirementsResponse,
+    purpose: "Link Jira requirements to a test case in QTM4J using the test case's human-readable key. Requirements can be specified by their human-readable keys (e.g. 'SCRUM-1') which are resolved to internal IDs automatically, or via a JQL filter. Requirements that cannot be linked are reported as warnings. PREREQUISITE: set_project_context must be called before this tool.",
+    useCases: [
+      "Link one or more Jira requirements (stories, bugs, epics) to a test case",
+      "Associate requirements with a test case using a JQL filter",
+      "Build traceability between requirements and test cases",
+      "Link requirements to a specific test case version"
+    ],
+    examples: [
+      {
+        description: "Link two requirements by key",
+        parameters: {
+          key: "SCRUM-TC-145",
+          requirementKeys: ["SCRUM-1", "SCRUM-2"]
+        },
+        expectedOutput: "Requirements SCRUM-1 and SCRUM-2 linked to test case"
+      },
+      {
+        description: "Link requirements by JQL filter",
+        parameters: {
+          key: "SCRUM-TC-145",
+          filter: { jql: "project = DEMO AND issuetype = Story" }
+        },
+        expectedOutput: "Requirements matched by JQL linked to test case"
+      },
+      {
+        description: "Link a requirement to a specific version",
+        parameters: {
+          key: "SCRUM-TC-85",
+          versionNo: 2,
+          requirementKeys: ["SCRUM-10"]
+        },
+        expectedOutput: "Requirement linked to version 2 of test case"
+      }
+    ],
+    hints: [
+      "PREREQUISITE: set_project_context must be called before this tool. NEVER auto-select a project.",
+      "KEY FORMAT: '{PROJECT_KEY}-TC-{number}' — e.g. 'SCRUM-TC-145'.",
+      "Requirement keys follow the Jira issue key format: '{PROJECT_KEY}-{number}' (e.g. 'SCRUM-1').",
+      "Provide either requirementKeys or filter.jql — not both.",
+      "If a requirement key cannot be resolved or linked, it is reported in warnings and other requirements are still linked.",
+      "versionNo defaults to the latest version. Use search_test_cases to find available versions if needed."
+    ],
+    outputDescription: "Confirmation with the test case key, version number, and linked: true. Warnings are included if any requirements could not be resolved or linked."
+  };
+  handle = async (rawArgs) => {
+    const args = LinkRequirementsBody.parse(rawArgs);
+    const fieldResolver = this.client.getResolverRegistry();
+    const context = fieldResolver.requireProjectContext();
+    const warnings = [];
+    const uidMap = await fieldResolver.getResolver(ResolverKeys.SearchableField.TEST_CASE_KEY_TO_UID).resolveAndReturn(context.projectId, [args.key]);
+    const entry = uidMap[args.key];
+    if (!entry) {
+      throw new ToolError(
+        `Test case '${args.key}' not found in project '${context.projectKey}'. Verify the key using the search_test_cases tool.`
+      );
+    }
+    const versionNo = args.versionNo ?? entry.latestVersion;
+    const body = {};
+    if (args.requirementKeys?.length) {
+      const reqMap = await fieldResolver.getResolver(ResolverKeys.SearchableField.REQUIREMENT_KEY_TO_ID).resolveAndReturn(context.projectId, args.requirementKeys);
+      const requirementIds = [];
+      for (const reqKey of args.requirementKeys) {
+        const resolved = reqMap[reqKey];
+        if (resolved) {
+          requirementIds.push(Number(resolved.id));
+        } else {
+          warnings.push(
+            `Requirement '${reqKey}' could not be resolved and was skipped.`
+          );
+        }
+      }
+      if (requirementIds.length > 0) body.requirementIds = requirementIds;
+    }
+    if (args.filter) {
+      body.filter = args.filter;
+    }
+    await this.client.getApiClient().post(ENDPOINTS.LINK_REQUIREMENTS(entry.uid, versionNo), body);
+    return {
+      structuredContent: LinkRequirementsResponse.parse({
+        key: args.key,
+        versionNo,
+        linked: true
+      }),
+      content: warnings.length > 0 ? [{ type: "text", text: `Note: ${warnings.join(" | ")}` }] : []
+    };
+  };
+}
+export {
+  LinkRequirements
+};

package/dist/qtm4j/tool/test-case/unlink-requirements.js

@@ -0,0 +1,116 @@
+import zod__default from "zod";
+import { Tool, ToolError } from "../../../common/tools.js";
+import { TOOLSETS, TOOL_NAMES, ENDPOINTS } from "../../config/constants.js";
+import { ResolverKeys } from "../../config/field-resolution.types.js";
+const UnlinkRequirementsBody = zod__default.object({
+  key: zod__default.string().describe(
+    "Test case key in '{PROJECT_KEY}-TC-{number}' format (e.g., 'SCRUM-TC-145'). Required."
+  ),
+  versionNo: zod__default.number().int().optional().describe("Test case version number. Defaults to the latest version."),
+  requirementKeys: zod__default.array(zod__default.string()).optional().describe(
+    "List of requirement keys to unlink (e.g., ['SCRUM-1', 'SCRUM-2']). Ignored when unLinkAll is true."
+  ),
+  unLinkAll: zod__default.boolean().optional().describe(
+    "If true, all linked requirements are unlinked from this test case. Ignores requirementKeys when set."
+  )
+});
+const UnlinkRequirementsResponse = zod__default.object({
+  key: zod__default.string(),
+  versionNo: zod__default.number().int(),
+  unlinked: zod__default.literal(true)
+});
+class UnlinkRequirements extends Tool {
+  specification = {
+    title: TOOL_NAMES.UNLINK_REQUIREMENTS.TITLE,
+    summary: TOOL_NAMES.UNLINK_REQUIREMENTS.SUMMARY,
+    readOnly: false,
+    idempotent: false,
+    toolset: TOOLSETS.TEST_CASES,
+    inputSchema: UnlinkRequirementsBody,
+    outputSchema: UnlinkRequirementsResponse,
+    purpose: "Unlink Jira requirements from a test case in QTM4J using the test case's human-readable key. Specify individual requirement keys to unlink (resolved to internal IDs automatically), or set unLinkAll to true to remove all linked requirements in one call. Requirements that cannot be unlinked are reported as warnings. PREREQUISITE: set_project_context must be called before this tool.",
+    useCases: [
+      "Remove specific requirements from a test case",
+      "Unlink all requirements from a test case at once",
+      "Clean up stale or incorrect requirement links from a test case",
+      "Remove requirement associations from a specific test case version"
+    ],
+    examples: [
+      {
+        description: "Unlink specific requirements by key",
+        parameters: {
+          key: "SCRUM-TC-145",
+          requirementKeys: ["SCRUM-1", "SCRUM-2"]
+        },
+        expectedOutput: "Requirements SCRUM-1 and SCRUM-2 unlinked from test case"
+      },
+      {
+        description: "Unlink all requirements from a test case",
+        parameters: { key: "SCRUM-TC-145", unLinkAll: true },
+        expectedOutput: "All requirements unlinked from test case"
+      },
+      {
+        description: "Unlink a requirement from a specific version",
+        parameters: {
+          key: "SCRUM-TC-85",
+          versionNo: 2,
+          requirementKeys: ["SCRUM-10"]
+        },
+        expectedOutput: "Requirement unlinked from version 2 of test case"
+      }
+    ],
+    hints: [
+      "PREREQUISITE: set_project_context must be called before this tool. NEVER auto-select a project.",
+      "KEY FORMAT: '{PROJECT_KEY}-TC-{number}' — e.g. 'SCRUM-TC-145'.",
+      "Requirement keys follow the Jira issue key format: '{PROJECT_KEY}-{number}' (e.g. 'SCRUM-1').",
+      "Set unLinkAll to true to remove all requirements in one call — no need to list them individually.",
+      "If a requirement key cannot be resolved or unlinked, it is reported in warnings and others are still unlinked.",
+      "versionNo defaults to the latest version. Use search_test_cases to find available versions if needed."
+    ],
+    outputDescription: "Confirmation with the test case key, version number, and unlinked: true. Warnings are included if any requirements could not be resolved or unlinked."
+  };
+  handle = async (rawArgs) => {
+    const args = UnlinkRequirementsBody.parse(rawArgs);
+    const fieldResolver = this.client.getResolverRegistry();
+    const context = fieldResolver.requireProjectContext();
+    const warnings = [];
+    const uidMap = await fieldResolver.getResolver(ResolverKeys.SearchableField.TEST_CASE_KEY_TO_UID).resolveAndReturn(context.projectId, [args.key]);
+    const entry = uidMap[args.key];
+    if (!entry) {
+      throw new ToolError(
+        `Test case '${args.key}' not found in project '${context.projectKey}'. Verify the key using the search_test_cases tool.`
+      );
+    }
+    const versionNo = args.versionNo ?? entry.latestVersion;
+    const body = {};
+    if (args.unLinkAll) {
+      body.unLinkAll = true;
+    } else if (args.requirementKeys?.length) {
+      const reqMap = await fieldResolver.getResolver(ResolverKeys.SearchableField.REQUIREMENT_KEY_TO_ID).resolveAndReturn(context.projectId, args.requirementKeys);
+      const requirementIds = [];
+      for (const reqKey of args.requirementKeys) {
+        const resolved = reqMap[reqKey];
+        if (resolved) {
+          requirementIds.push(Number(resolved.id));
+        } else {
+          warnings.push(
+            `Requirement '${reqKey}' could not be resolved and was skipped.`
+          );
+        }
+      }
+      if (requirementIds.length > 0) body.requirementIds = requirementIds;
+    }
+    await this.client.getApiClient().post(ENDPOINTS.UNLINK_REQUIREMENTS(entry.uid, versionNo), body);
+    return {
+      structuredContent: UnlinkRequirementsResponse.parse({
+        key: args.key,
+        versionNo,
+        unlinked: true
+      }),
+      content: warnings.length > 0 ? [{ type: "text", text: `Note: ${warnings.join(" | ")}` }] : []
+    };
+  };
+}
+export {
+  UnlinkRequirements
+};

package/dist/qtm4j/tool/test-case/update-test-case.js

@@ -1,5 +1,5 @@
 import { Tool, ToolError } from "../../../common/tools.js";
-import { TOOL_NAMES, ENDPOINTS } from "../../config/constants.js";
+import { TOOL_NAMES, TOOLSETS, ENDPOINTS } from "../../config/constants.js";
 import { ResolverKeys, InputField } from "../../config/field-resolution.types.js";
 import { UpdateTestCaseResponse, UpdateTestCaseBody } from "../../schema/update-test-case.schema.js";
 const SIMPLE_FIELD_CONFIG = {
@@ -33,6 +33,7 @@ async function resolveAddDelete(resolver, inputField, resolverKey, field, contex
 class UpdateTestCase extends Tool {
   specification = {
     title: TOOL_NAMES.UPDATE_TEST_CASE.TITLE,
+    toolset: TOOLSETS.TEST_CASES,
     summary: TOOL_NAMES.UPDATE_TEST_CASE.SUMMARY,
     readOnly: false,
     idempotent: true,

package/dist/qtm4j/tool/test-cycle/create-test-cycle.js

@@ -1,5 +1,5 @@
 import { Tool } from "../../../common/tools.js";
-import { TOOL_NAMES, ENDPOINTS } from "../../config/constants.js";
+import { TOOL_NAMES, TOOLSETS, ENDPOINTS } from "../../config/constants.js";
 import { ResolverKeys, InputField } from "../../config/field-resolution.types.js";
 import { CreateTestCycleResponse, CreateTestCycleBody } from "../../schema/test-cycle.schema.js";
 const FIELD_CONFIG = {
@@ -13,6 +13,7 @@ class CreateTestCycle extends Tool {
   // ─── Tool Specification ────────────────────────────────────────────────────
   specification = {
     title: TOOL_NAMES.CREATE_TEST_CYCLE.TITLE,
+    toolset: TOOLSETS.TEST_CYCLES,
     summary: TOOL_NAMES.CREATE_TEST_CYCLE.SUMMARY,
     readOnly: false,
     idempotent: false,