targetprocess-mcp-server 2.0.0 → 2.0.1

package/README.md

@@ -24,9 +24,9 @@ It acts as a **bridge between LLM agents and the Targetprocess API**, providing:
 
 - "Show me currently active release"
 - "write me test cases based on 145322 tp user story"
+- "write detailed test cases based on 145642 bug, format them inside html <div> element, create a test plan and add test cases to it"
 - "add a comment to 145155 card saying 'test'"
-- "write test cases based on 145640 user story"
-- "write detailed test cases based on 145642 user story, format them inside html <div> element and add them as a comment"
+- "write test cases based on 145640 feature"
 - "create a bug based on 145637 user story where Add Tile flyout (for a Static Tile) not show"
 - "search for a card with 'Text Element' title"
 
@@ -56,7 +56,12 @@ Cards — Write
 - `add_comment` — Post a comment to any card (id, comment)
 - `create_bug` — Create a standalone bug (title, bugContent, optional origin)
 - `create_bug_based_on_card` — Create a bug linked to an existing user story or bug card (card object with id+type, title, bugContent, optional origin)
-- `create_test_plan` — Create a test plan linked to a user story (title, userStoryId)
+- `create_test_plan` — Create a test plan linked to a UserStory, Bug, or Feature (title, resourceId, optional resourceType, optional description/startDate/endDate)
+- `add_test_cases` — Create a test plan and add generated test cases to it in one call (resourceId, testPlanTitle, testCases array of {name, description}, optional resourceType)
+
+Test Case Workflows
+- `write_test_cases` — Fetch a card (UserStory, Bug, or Feature) by ID and trigger the full test case writing workflow: Claude analyzes the card, generates detailed HTML-formatted test cases covering happy path, edge cases, and error scenarios, creates a linked test plan, then calls `add_test_cases_to_test_plan` (resourceId, optional resourceType)
+- `add_test_cases_to_test_plan` — Add an array of pre-generated test cases to an existing test plan by its ID (testPlanId, testCases array of {name, description})
 
 Projects
 - `get_projects` — Get all Targetprocess projects (no params needed)

package/build/index.js

@@ -692,23 +692,30 @@ server.registerTool('create_bug', {
     };
 });
 server.registerTool('create_test_plan', {
-    title: 'Create a new test plan for a user story',
-    description: `Create a new test plan with provided title and user story id`,
+    title: 'Create a new test plan linked to a TP card',
+    description: `Create a new test plan linked to a UserStory, Bug, or Feature. Name and Project are required by the API; Description, StartDate, and EndDate are optional.`,
     inputSchema: {
         title: z.string()
-            .describe(`Test plan title that is taken from user story title`),
-        userStoryId: z.string()
+            .describe('Test plan title — use the linked card name with a prefix (e.g. "Test Plan: User story title")'),
+        resourceId: z.string()
             .min(5)
             .max(6)
-            .describe(`User story id, usually user story or bug ID (e.g. 145789)`),
+            .describe('ID of the card to link this test plan to (e.g. 145789)'),
+        resourceType: z.enum(['UserStory', 'Bug', 'Feature'])
+            .default('UserStory')
+            .optional()
+            .describe('Type of the linked card — UserStory, Bug, or Feature (default: UserStory)'),
+        description: z.string()
+            .optional()
+            .describe('Optional description of the test plan scope or goals')
     },
-}, async ({ title, userStoryId }) => {
-    const testPlanResponse = await tp.createTestPlan(title, userStoryId);
+}, async ({ title, resourceId, resourceType, description }) => {
+    const testPlanResponse = await tp.createTestPlan(title, resourceId, resourceType, { description });
     if (!testPlanResponse) {
         return {
             content: [{
                     type: 'text',
-                    text: `Failed to create testPlanResponse "${title}"\n JSON: ${JSON.stringify(testPlanResponse, null, 2)}`
+                    text: `Failed to create test plan "${title}" for ${resourceType} id: ${resourceId}`
                 }]
         };
     }
@@ -939,6 +946,110 @@ server.registerTool('get_logged_in_user', {
             }],
     };
 });
+server.registerTool('write_test_cases', {
+    title: 'Write test cases for a TP card (UserStory, Bug, or Feature)',
+    description: `Fetches a TP card (UserStory, Bug, or Feature) content by ID.
+      CRITICAL WORKFLOW — after receiving the card content, you MUST:
+        1) Thoroughly analyze the card name and description to understand the feature or issue being tested
+        2) Write detailed test cases covering: happy path, edge cases, boundary conditions, and error scenarios
+        3) Format each test case description inside an html <div> element structured as:
+            <div>
+              <p><strong>Preconditions:</strong> ...</p>
+              <p><strong>Test Steps:</strong><ol><li>...</li></ol></p>
+              <p><strong>Expected Result:</strong> ...</p>
+              <p><strong>Test Type:</strong> ...</p>
+            </div>
+        4) Call "create_test_plan" tool passing: resourceId (the card id), resourceType, testPlanTitle (use the card name prefixed with "Test Plan: "), and the testCases array
+        5) Call "add_test_case_to_test_plan" tool passing: testPlanId (the test plan id), and the testCases array`,
+    inputSchema: {
+        resourceId: z.string()
+            .min(5)
+            .max(6)
+            .describe('TP card ID (e.g. 145789)'),
+        resourceType: z.enum(['UserStory', 'Bug', 'Feature'])
+            .default('UserStory')
+            .optional()
+            .describe('Type of the TP card — UserStory, Bug, or Feature (default: UserStory)'),
+    },
+}, async ({ resourceId, resourceType = 'UserStory' }) => {
+    let card = null;
+    if (resourceType === 'Bug') {
+        card = await tp.getBug(resourceId);
+    }
+    else if (resourceType === 'Feature') {
+        card = await tp.getFeature(resourceId);
+    }
+    else {
+        card = await tp.getUserStory(resourceId);
+    }
+    if (!card) {
+        return {
+            content: [{
+                    type: 'text',
+                    text: `Failed to get ${resourceType} with id: ${resourceId}`
+                }],
+        };
+    }
+    let description = '';
+    try {
+        const dom = new JSDOM(`<html><body><div id="content">${card.Description}</div></body></html>`);
+        description = dom.window.document.getElementById('content')?.textContent || '';
+    }
+    catch (error) {
+        console.error("Error parsing card description:", error);
+    }
+    return {
+        content: [{
+                type: 'text',
+                text: JSON.stringify({
+                    id: card.Id,
+                    name: card.Name,
+                    resourceType,
+                    description,
+                    customFields: card.CustomFields,
+                })
+            }],
+    };
+});
+server.registerTool('add_test_cases_to_test_plan', {
+    title: 'Adds generated test cases to a test plan linked to a TP card (UserStory, Bug, or Feature).',
+    description: `Adds generated test cases to a test plan linked to a TP card (UserStory, Bug, or Feature).`,
+    inputSchema: {
+        testPlanId: z.string()
+            .min(5)
+            .max(6)
+            .describe('TP card ID to link the test plan to (e.g. 145789)'),
+        testCases: z.array(z.object({
+            name: z.string()
+                .describe('Test case title (concise, action-oriented)'),
+            description: z.string()
+                .describe('Test case steps and expected results formatted as HTML'),
+        }))
+            .min(1)
+            .describe('Array of test cases to create in the new test plan'),
+    },
+}, async ({ testPlanId, testCases }) => {
+    const created = [];
+    const failed = [];
+    for (const tc of testCases) {
+        const result = await tp.createTestCase(tc.name, tc.description, String(testPlanId));
+        if (result) {
+            created.push({ id: result.Id, name: result.Name });
+        }
+        else {
+            failed.push(tc.name);
+        }
+    }
+    return {
+        content: [{
+                type: 'text',
+                text: JSON.stringify({
+                    created,
+                    failed,
+                })
+            }]
+    };
+});
 async function main() {
     const transport = new StdioServerTransport();
     await server.connect(transport);

package/build/tp.js

@@ -92,6 +92,13 @@ export class TpClient {
         });
         return response;
     }
+    async getFeature(featureId) {
+        const response = await this.get({
+            pathParam: { "features": featureId },
+            param: { "format": "json" }
+        });
+        return response;
+    }
     async createBug({ title, card, bugContent, origin = "Manual QA" }) {
         const bug = {
             "Name": title,
@@ -169,7 +176,21 @@ export class TpClient {
             param: { "format": "json" },
         }, bug);
     }
-    async createTestPlan(title, userStoryId) {
+    async createTestCase(name, description, testPlanId) {
+        const testCase = {
+            "Name": name,
+            "Project": { "Id": config.tp.projectId },
+            "Description": description,
+            "TestPlans": [{
+                    "Id": testPlanId
+                }],
+        };
+        return this.post({
+            pathParam: { "testCases": '' },
+            param: { "format": "json" },
+        }, testCase);
+    }
+    async createTestPlan(title, resourceId, resourceType = 'UserStory', options) {
         const testPlan = {
             "Name": title,
             "Project": {
@@ -177,20 +198,30 @@ export class TpClient {
             },
             "LinkedGeneral": {
                 "ResourceType": "General",
-                "Id": userStoryId,
+                "Id": resourceId,
                 "Name": title,
             },
             "LinkedAssignable": {
                 "ResourceType": "Assignable",
-                "Id": userStoryId,
-                "Name": title,
-            },
-            "LinkedUserStory": {
-                "ResourceType": "UserStory",
-                "Id": userStoryId,
+                "Id": resourceId,
                 "Name": title,
             },
         };
+        if (resourceType === 'UserStory') {
+            testPlan["LinkedUserStory"] = { "ResourceType": "UserStory", "Id": resourceId, "Name": title };
+        }
+        else if (resourceType === 'Bug') {
+            testPlan["LinkedBug"] = { "ResourceType": "Bug", "Id": resourceId, "Name": title };
+        }
+        else if (resourceType === 'Feature') {
+            testPlan["LinkedFeature"] = { "ResourceType": "Feature", "Id": resourceId, "Name": title };
+        }
+        if (options?.description)
+            testPlan["Description"] = options.description;
+        if (options?.startDate)
+            testPlan["StartDate"] = options.startDate;
+        if (options?.endDate)
+            testPlan["EndDate"] = options.endDate;
         return this.post({
             pathParam: { "testPlans": '' },
             param: { "format": "json" },

package/package.json

@@ -25,7 +25,7 @@
   "engines": {
     "node": ">=20.x"
   },
-  "version": "2.0.0",
+  "version": "2.0.1",
   "description": "MCP server for Tartget Process",
   "main": "build/index.js",
   "keywords": [