targetprocess-mcp-server 2.5.2 → 2.5.3

package/README.md

@@ -109,6 +109,14 @@ Cards — Write
 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 test cases covering happy path, edge cases, and error scenarios, creates a linked test plan via `create_test_plan`, then calls `add_test_cases_to_test_plan`. Each test case description contains Preconditions and Test Type as HTML; steps are passed as a structured array (resourceId, optional resourceType)
 - `add_test_cases_to_test_plan` — Add pre-generated test cases to an existing test plan. Each test case has a `name`, an HTML `description` (Preconditions and Test Type only), and a `steps` array of `{ description, result }` objects — steps are created via the TP test step API rather than embedded in the description (testPlanId, testCases array of {name, description, steps})
+- `get_test_plan_by_id` — Get a test plan by ID, including name, plain-text description, state, project, and linked card (id)
+- `get_test_plan_test_cases_by_id` — Get test cases for a test plan by ID, including cases from nested child test plans/containers; returns id, name, plain-text description, and containing test plan metadata, no steps (id)
+- `get_test_plan_test_cases_with_steps_by_id` — Get test cases directly on a test plan by ID, each with its steps (id)
+- `get_test_case_by_id` — Get a single test case by ID, including plain-text description and its steps (id)
+- `update_test_case_by_id` — Update a test case's name and/or description (id, optional name, optional description)
+- `add_test_case_step_by_id` — Add a new step to a test case (testCaseId, description, result)
+- `update_test_case_step_by_id` — Update a test step's description and/or result (id, optional description, optional result)
+- `delete_test_case_step_by_id` — Delete a test step by ID (id)
 
 Processes & Workflows
 - `get_processes` — Get all Targetprocess processes (no params needed)
@@ -219,7 +227,7 @@ npx vitest            # watch mode
 
 ### Coverage
 
-**33 of 46 tools (72%) are covered by unit tests.**
+**53 of 64 tools (83%) are covered by unit tests.**
 
 | Test file | Handlers covered |
 |---|---|
@@ -236,3 +244,8 @@ npx vitest            # watch mode
 | `creation_tools.test.ts` | `create_bug`, `create_user_story`, `create_feature`, `create_task`, `update_bug`, `update_user_story_state` |
 | `my_work_tools.test.ts` | `get_in_progress_tasks_and_bugs`, `list_my_user_stories`, `list_my_bugs`, `log_time`, `get_my_time_logs` |
 | `entity_tools.test.ts` | `get_feature_user_stories`, `get_user_story_bugs`, `get_card_current_status` |
+| `relation_tools.test.ts` | `get_card_relations`, `create_card_relation`, `delete_card_relation` |
+| `epic_tools.test.ts` | `create_epic`, `get_epic_content`, `update_epic`, `get_epic_features` |
+| `test_plan_tools.test.ts` | `get_test_plan_by_id`, `get_test_plan_test_cases_by_id`, `get_test_plan_test_cases_with_steps_by_id` |
+| `test_case_tools.test.ts` | `get_test_case_by_id`, `update_test_case_by_id`, `add_test_case_step_by_id`, `update_test_case_step_by_id`, `delete_test_case_step_by_id` |
+| `workflow_tools.test.ts` | `get_processes`, `get_process_workflows`, `get_bug_workflows`, `get_user_story_workflows`, `get_relation_types`, `get_version` |

package/build/handlers/add_test_case_step_by_id.js

@@ -0,0 +1,17 @@
+export async function handleAddTestCaseStepById(tp, params) {
+    const testStepResponse = await tp.addTestStep(params.testCaseId, {
+        description: params.description,
+        result: params.result,
+    });
+    if (!testStepResponse) {
+        return {
+            content: [{
+                    type: 'text',
+                    text: `Failed to add test step to test case id: ${params.testCaseId}\n JSON: ${JSON.stringify(testStepResponse, null, 2)}`
+                }],
+        };
+    }
+    return {
+        content: [{ type: 'text', text: JSON.stringify(testStepResponse) }],
+    };
+}

package/build/handlers/delete_test_case_step_by_id.js

@@ -0,0 +1,19 @@
+export async function handleDeleteTestCaseStepById(tp, id) {
+    const result = await tp.deleteTestStep(id);
+    if (!result.ok) {
+        return {
+            content: [{
+                    type: 'text',
+                    text: `Failed to delete test step id: ${id}\n` +
+                        `HTTP status: ${result.status}\n` +
+                        `Response body: ${result.body}`
+                }],
+        };
+    }
+    return {
+        content: [{
+                type: 'text',
+                text: JSON.stringify({ deleted: true, testStepId: Number(id), testStep: result.data })
+            }],
+    };
+}

package/build/handlers/get_bug_workflows.js

@@ -0,0 +1,33 @@
+export async function handleGetBugWorkflows(tp) {
+    const response = await tp.getBugWorkflows();
+    if (!response) {
+        return {
+            content: [{
+                    type: 'text',
+                    text: `Failed to get bug entity statuses, JSON: ${JSON.stringify(response, null, 2)}`
+                }],
+        };
+    }
+    const items = response.items || [];
+    if (items.length === 0) {
+        return {
+            content: [{
+                    type: 'text',
+                    text: `No status data found for workflows`
+                }],
+        };
+    }
+    const workflows = items.map((w) => ({
+        id: w.id,
+        name: w.name,
+        processId: w.process,
+        entityType: w.entityType,
+        entityStates: w.entityStates.map((es) => ({
+            id: es.id,
+            name: es.name,
+        })),
+    }));
+    return {
+        content: [{ type: 'text', text: JSON.stringify(workflows) }],
+    };
+}

package/build/handlers/get_process_workflows.js

@@ -0,0 +1,23 @@
+export async function handleGetProcessWorkflows(tp, processId) {
+    const response = await tp.getProcessWorkflows({ processId });
+    if (!response) {
+        return {
+            content: [{
+                    type: 'text',
+                    text: `Failed to get process workflows, JSON: ${JSON.stringify(response, null, 2)}`
+                }],
+        };
+    }
+    const items = response.items || [];
+    if (items.length === 0) {
+        return {
+            content: [{
+                    type: 'text',
+                    text: `No process workflows found`,
+                }],
+        };
+    }
+    return {
+        content: [{ type: 'text', text: JSON.stringify(items) }],
+    };
+}

package/build/handlers/get_processes.js

@@ -0,0 +1,23 @@
+export async function handleGetProcesses(tp) {
+    const response = await tp.getProcesses();
+    if (!response) {
+        return {
+            content: [{
+                    type: 'text',
+                    text: `Failed to get processes, JSON: ${JSON.stringify(response, null, 2)}`
+                }],
+        };
+    }
+    const items = response.items || [];
+    if (items.length === 0) {
+        return {
+            content: [{
+                    type: 'text',
+                    text: `No processes found`,
+                }],
+        };
+    }
+    return {
+        content: [{ type: 'text', text: JSON.stringify(items) }],
+    };
+}

package/build/handlers/get_relation_types.js

@@ -0,0 +1,12 @@
+export async function handleGetRelationTypes(tp) {
+    const response = await tp.getRelationTypes();
+    if (!response) {
+        return {
+            content: [{ type: 'text', text: `Failed to get relation types` }],
+        };
+    }
+    const items = (response.Items || []).map((t) => ({ id: t.Id, name: t.Name }));
+    return {
+        content: [{ type: 'text', text: JSON.stringify(items) }],
+    };
+}

package/build/handlers/get_test_case_by_id.js

@@ -0,0 +1,37 @@
+import { JSDOM } from 'jsdom';
+export async function handleGetTestCaseById(tp, id) {
+    const testCase = await tp.getTestCase(id);
+    if (!testCase) {
+        return {
+            content: [{
+                    type: 'text',
+                    text: `Failed to get test case id: ${id}\n JSON: ${JSON.stringify(testCase, null, 2)}`
+                }],
+        };
+    }
+    let description = '';
+    if (testCase.Description) {
+        try {
+            const dom = new JSDOM(`<html><body><div id="content">${testCase.Description}</div></body></html>`);
+            description = dom.window.document.getElementById('content')?.textContent || '';
+        }
+        catch (error) {
+            console.error('Error parsing test case description:', error);
+        }
+    }
+    const testCaseSteps = await tp.getTestCaseSteps(String(testCase.Id));
+    const result = {
+        id: testCase.Id,
+        name: testCase.Name,
+        description,
+        testPlan: testCase.TestPlans?.Items?.[0]?.Name ?? testCase.LinkedTestPlan?.Name,
+        steps: testCaseSteps?.Items?.map((step) => ({
+            description: step.Description,
+            result: step.Result,
+            runOrder: step.RunOrder,
+        })) || [],
+    };
+    return {
+        content: [{ type: 'text', text: JSON.stringify(result) }],
+    };
+}

package/build/handlers/get_test_plan_by_id.js

@@ -0,0 +1,36 @@
+import { JSDOM } from 'jsdom';
+export async function handleGetTestPlanById(tp, id) {
+    const testPlan = await tp.getTestPlan(id);
+    if (!testPlan) {
+        return {
+            content: [{
+                    type: "text",
+                    text: `Failed to get test plan id: ${id}\n JSON: ${JSON.stringify(testPlan, null, 2)}`
+                }],
+        };
+    }
+    let description = '';
+    if (testPlan.Description) {
+        try {
+            const dom = new JSDOM(`<html><body><div id="content">${testPlan.Description}</div></body></html>`);
+            description = dom.window.document.getElementById('content')?.textContent || '';
+        }
+        catch (error) {
+            console.error('Error parsing test plan description:', error);
+        }
+    }
+    const result = {
+        id: testPlan.Id,
+        name: testPlan.Name,
+        description,
+        entityState: testPlan.EntityState?.Name,
+        project: testPlan.Project?.Name,
+        linkedUserStory: testPlan.LinkedUserStory?.Name,
+        linkedAssignable: testPlan.LinkedAssignable?.Name,
+        createDate: testPlan.CreateDate,
+        modifyDate: testPlan.ModifyDate,
+    };
+    return {
+        content: [{ type: 'text', text: JSON.stringify(result) }],
+    };
+}

package/build/handlers/get_test_plan_test_cases_by_id.js

@@ -0,0 +1,43 @@
+import { JSDOM } from 'jsdom';
+export async function handleGetTestPlanTestCasesById(tp, id) {
+    const response = await tp.getIndirectTestPlanTestCases(id);
+    if (!response) {
+        return {
+            content: [{
+                    type: 'text',
+                    text: `Failed to get test cases for test plan id: ${id}\n JSON: ${JSON.stringify(response, null, 2)}`
+                }],
+        };
+    }
+    const items = response.Items || [];
+    if (items.length === 0) {
+        return {
+            content: [{
+                    type: 'text',
+                    text: `No test cases found for test plan id: ${id}`,
+                }],
+        };
+    }
+    const testCases = items.map((item) => {
+        let description = '';
+        if (item.Description) {
+            try {
+                const dom = new JSDOM(`<html><body><div id="content">${item.Description}</div></body></html>`);
+                description = dom.window.document.getElementById('content')?.textContent || '';
+            }
+            catch (error) {
+                console.error('Error parsing test case description:', error);
+            }
+        }
+        return {
+            id: item.Id,
+            name: item.Name,
+            description,
+            testPlanId: item.TestPlanId,
+            testPlanName: item.TestPlanName,
+        };
+    });
+    return {
+        content: [{ type: 'text', text: JSON.stringify(testCases) }],
+    };
+}

package/build/handlers/get_test_plan_test_cases_with_steps_by_id.js

@@ -0,0 +1,49 @@
+import { JSDOM } from 'jsdom';
+export async function handleGetTestPlanTestCasesWithStepsById(tp, id) {
+    const response = await tp.getTestPlanTestCases(id);
+    if (!response) {
+        return {
+            content: [{
+                    type: 'text',
+                    text: `Failed to get test cases for test plan id: ${id}\n JSON: ${JSON.stringify(response, null, 2)}`
+                }],
+        };
+    }
+    const items = response.Items || [];
+    if (items.length === 0) {
+        return {
+            content: [{
+                    type: 'text',
+                    text: `No test cases found for test plan id: ${id}`,
+                }],
+        };
+    }
+    const testCasesData = await Promise.all(items.map(async (item) => {
+        let description = '';
+        if (item.Description) {
+            try {
+                const dom = new JSDOM(`<html><body><div id="content">${item.Description}</div></body></html>`);
+                description = dom.window.document.getElementById('content')?.textContent || '';
+            }
+            catch (error) {
+                console.error('Error parsing test case description:', error);
+            }
+        }
+        const testCaseSteps = await tp.getTestCaseSteps(String(item.Id));
+        return {
+            testCaseId: item.Id,
+            testCaseName: item.Name,
+            testCaseDescription: description,
+            testPlanId: item.TestPlanId,
+            testPlanName: item.TestPlanName,
+            testCaseSteps: testCaseSteps?.Items?.map((step) => ({
+                description: step.Description,
+                result: step.Result,
+                runOrder: step.RunOrder,
+            })) || [],
+        };
+    }));
+    return {
+        content: [{ type: 'text', text: JSON.stringify(testCasesData) }],
+    };
+}

package/build/handlers/get_user_story_workflows.js

@@ -0,0 +1,33 @@
+export async function handleGetUserStoryWorkflows(tp) {
+    const response = await tp.getUserStoryWorkflowsWithSubStates();
+    if (!response) {
+        return {
+            content: [{
+                    type: 'text',
+                    text: `Failed to get user story entity statuses, JSON: ${JSON.stringify(response, null, 2)}`
+                }],
+        };
+    }
+    const items = response.items || [];
+    if (items.length === 0) {
+        return {
+            content: [{
+                    type: 'text',
+                    text: `No status data found for workflows`
+                }],
+        };
+    }
+    const userStoryWorkflows = items.filter((w) => w.entityType.name === "UserStory");
+    const workflows = userStoryWorkflows.map((w) => ({
+        id: w.id,
+        processId: w.workflow.process.id,
+        entityType: w.entityType.name,
+        entityStates: w.subEntityStates.map((es) => ({
+            id: es.id,
+            name: es.name,
+        })),
+    }));
+    return {
+        content: [{ type: 'text', text: JSON.stringify(workflows) }],
+    };
+}

package/build/handlers/get_version.js

@@ -0,0 +1,5 @@
+export async function handleGetVersion(version) {
+    return {
+        content: [{ type: 'text', text: version }],
+    };
+}

package/build/handlers/update_test_case_by_id.js

@@ -0,0 +1,22 @@
+export async function handleUpdateTestCaseById(tp, params) {
+    if (params.name === undefined && params.description === undefined) {
+        return {
+            content: [{
+                    type: 'text',
+                    text: `Nothing to update for test case id: ${params.id}`
+                }],
+        };
+    }
+    const testCaseResponse = await tp.updateTestCase(params);
+    if (!testCaseResponse) {
+        return {
+            content: [{
+                    type: 'text',
+                    text: `Failed to update test case id: ${params.id}\n JSON: ${JSON.stringify(testCaseResponse, null, 2)}`
+                }],
+        };
+    }
+    return {
+        content: [{ type: 'text', text: JSON.stringify(testCaseResponse) }],
+    };
+}

package/build/handlers/update_test_case_step_by_id.js

@@ -0,0 +1,35 @@
+export async function handleUpdateTestCaseStepById(tp, params) {
+    if (params.description === undefined && params.result === undefined) {
+        return {
+            content: [{
+                    type: 'text',
+                    text: `Nothing to update for test step id: ${params.id}`
+                }],
+        };
+    }
+    const existingTestStep = await tp.getTestStep(params.id);
+    if (!existingTestStep) {
+        return {
+            content: [{
+                    type: 'text',
+                    text: `Failed to get test step id: ${params.id}\n JSON: ${JSON.stringify(existingTestStep, null, 2)}`
+                }],
+        };
+    }
+    const testStepResponse = await tp.updateTestStep({
+        id: params.id,
+        description: params.description ?? existingTestStep.Description,
+        result: params.result ?? existingTestStep.Result,
+    });
+    if (!testStepResponse) {
+        return {
+            content: [{
+                    type: 'text',
+                    text: `Failed to update test step id: ${params.id}\n JSON: ${JSON.stringify(testStepResponse, null, 2)}`
+                }],
+        };
+    }
+    return {
+        content: [{ type: 'text', text: JSON.stringify(testStepResponse) }],
+    };
+}

package/build/index.js

@@ -44,6 +44,20 @@ import { handleUpdateUserStorySubState } from "./handlers/update_user_story_sub_
 import { handleGetCardRelations } from "./handlers/get_card_relations.js";
 import { handleCreateCardRelation } from "./handlers/create_card_relation.js";
 import { handleDeleteCardRelation } from "./handlers/delete_card_relation.js";
+import { handleGetTestPlanById } from "./handlers/get_test_plan_by_id.js";
+import { handleGetTestPlanTestCasesById } from "./handlers/get_test_plan_test_cases_by_id.js";
+import { handleGetTestPlanTestCasesWithStepsById } from "./handlers/get_test_plan_test_cases_with_steps_by_id.js";
+import { handleGetTestCaseById } from "./handlers/get_test_case_by_id.js";
+import { handleUpdateTestCaseById } from "./handlers/update_test_case_by_id.js";
+import { handleAddTestCaseStepById } from "./handlers/add_test_case_step_by_id.js";
+import { handleUpdateTestCaseStepById } from "./handlers/update_test_case_step_by_id.js";
+import { handleDeleteTestCaseStepById } from "./handlers/delete_test_case_step_by_id.js";
+import { handleGetProcessWorkflows } from "./handlers/get_process_workflows.js";
+import { handleGetProcesses } from "./handlers/get_processes.js";
+import { handleGetBugWorkflows } from "./handlers/get_bug_workflows.js";
+import { handleGetUserStoryWorkflows } from "./handlers/get_user_story_workflows.js";
+import { handleGetRelationTypes } from "./handlers/get_relation_types.js";
+import { handleGetVersion } from "./handlers/get_version.js";
 const server = new McpServer({
     name: "tp",
     version: "1.0.0"
@@ -95,7 +109,7 @@ server.registerTool('get_release_bugs', {
         name: z.string()
             .describe('Release name'),
         results: z.number()
-            .default(100)
+            .default(300)
             .optional()
             .describe('Number of results to return, default is 100'),
         withDescription: z.boolean()
@@ -1149,139 +1163,19 @@ server.registerTool('get_process_workflows', {
         processId: z.string()
             .describe('Process ID (e.g. 145636)'),
     },
-}, async ({ processId }) => {
-    const response = await tp.getProcessWorkflows({ processId });
-    if (!response) {
-        return {
-            content: [{
-                    type: 'text',
-                    text: `Failed to get process workflows, JSON: ${JSON.stringify(response, null, 2)}`
-                }],
-        };
-    }
-    const items = response.items || [];
-    if (items.length === 0) {
-        return {
-            content: [{
-                    type: 'text',
-                    text: `No process workflows found`,
-                }],
-        };
-    }
-    return {
-        content: [{
-                type: 'text',
-                text: JSON.stringify(items)
-            }],
-    };
-});
+}, async ({ processId }) => handleGetProcessWorkflows(tp, processId));
 server.registerTool('get_processes', {
     title: 'Get processes',
     description: 'Get all Targetprocess processes',
-}, async ({}) => {
-    const response = await tp.getProcesses();
-    if (!response) {
-        return {
-            content: [{
-                    type: 'text',
-                    text: `Failed to get processes, JSON: ${JSON.stringify(response, null, 2)}`
-                }],
-        };
-    }
-    const items = response.items || [];
-    if (items.length === 0) {
-        return {
-            content: [{
-                    type: 'text',
-                    text: `No processes found`,
-                }],
-        };
-    }
-    return {
-        content: [{
-                type: 'text',
-                text: JSON.stringify(items)
-            }],
-    };
-});
+}, async () => handleGetProcesses(tp));
 server.registerTool('get_bug_workflows', {
     title: 'Get bug workflows',
     description: 'Get all Targetprocess bug workflows',
-}, async ({}) => {
-    const response = await tp.getBugWorkflows();
-    if (!response) {
-        return {
-            content: [{
-                    type: 'text',
-                    text: `Failed to get bug entity statuses, JSON: ${JSON.stringify(response, null, 2)}`
-                }],
-        };
-    }
-    const items = response.items || [];
-    if (items.length === 0) {
-        return {
-            content: [{
-                    type: 'text',
-                    text: `No status data found for workflows`
-                }],
-        };
-    }
-    const workflows = items.map((w) => ({
-        id: w.id,
-        name: w.name,
-        processId: w.process,
-        entityType: w.entityType,
-        entityStates: w.entityStates.map((es) => ({
-            id: es.id,
-            name: es.name,
-        })),
-    }));
-    return {
-        content: [{
-                type: 'text',
-                text: JSON.stringify(workflows)
-            }],
-    };
-});
+}, async () => handleGetBugWorkflows(tp));
 server.registerTool('get_user_story_workflows', {
     title: 'Get User Story workflows',
     description: 'Get all Targetprocess user story workflows, with sub-states',
-}, async ({}) => {
-    const response = await tp.getUserStoryWorkflowsWithSubStates();
-    if (!response) {
-        return {
-            content: [{
-                    type: 'text',
-                    text: `Failed to get user story entity statuses, JSON: ${JSON.stringify(response, null, 2)}`
-                }],
-        };
-    }
-    const items = response.items || [];
-    if (items.length === 0) {
-        return {
-            content: [{
-                    type: 'text',
-                    text: `No status data found for workflows`
-                }],
-        };
-    }
-    const userStoryWorkflows = items.filter((w) => w.entityType.name === "UserStory");
-    const workflows = userStoryWorkflows.map((w) => ({
-        id: w.id,
-        processId: w.workflow.process.id,
-        entityType: w.entityType.name,
-        entityStates: w.subEntityStates.map((es) => ({
-            id: es.id,
-            name: es.name,
-        })),
-    }));
-    return {
-        content: [{
-                type: 'text',
-                text: JSON.stringify(workflows)
-            }],
-    };
-});
+}, async () => handleGetUserStoryWorkflows(tp));
 server.registerTool('get_card_current_status', {
     title: 'Get card status',
     description: 'Get the EntityState, TeamState, and assigned teams for a TP card (UserStory, Bug, or Feature) by ID',
@@ -1312,18 +1206,7 @@ server.registerTool('get_card_relations', {
 server.registerTool('get_relation_types', {
     title: 'Get relation types',
     description: 'Get all relation types available in this Targetprocess instance (id + name). Use this to find the correct relationType name for "create_card_relation".',
-}, async () => {
-    const response = await tp.getRelationTypes();
-    if (!response) {
-        return {
-            content: [{ type: 'text', text: `Failed to get relation types` }],
-        };
-    }
-    const items = (response.Items || []).map((t) => ({ id: t.Id, name: t.Name }));
-    return {
-        content: [{ type: 'text', text: JSON.stringify(items) }],
-    };
-});
+}, async () => handleGetRelationTypes(tp));
 server.registerTool('create_card_relation', {
     title: 'Create a relation between two cards',
     description: `Create a relation between two TP cards (UserStory, Bug, Feature, etc.).
@@ -1459,9 +1342,103 @@ server.registerTool('get_version', {
     title: 'Get server version',
     description: 'Returns the current version of the MCP server from package.json.',
     inputSchema: {},
-}, async () => ({
-    content: [{ type: "text", text: version }]
-}));
+}, async () => handleGetVersion(version));
+server.registerTool('get_test_plan_by_id', {
+    title: 'Get test plan by ID',
+    description: 'Get a Targetprocess Test Plan by its ID, including name, plain-text description, state, and linked card.',
+    inputSchema: {
+        id: z.string()
+            .min(5)
+            .max(6)
+            .describe('Test plan ID (e.g. 145789)'),
+    },
+}, async ({ id }) => handleGetTestPlanById(tp, id));
+server.registerTool('get_test_plan_test_cases_by_id', {
+    title: 'Get test plan test cases by ID',
+    description: 'Get test cases belonging to a Targetprocess Test Plan by plan ID, including cases in nested child test plans/containers. Returns id, name, plain-text description, and containing test plan metadata (no steps).',
+    inputSchema: {
+        id: z.string()
+            .min(5)
+            .max(6)
+            .describe('Test plan ID (e.g. 145789)'),
+    },
+}, async ({ id }) => handleGetTestPlanTestCasesById(tp, id));
+server.registerTool('get_test_plan_test_cases_with_steps_by_id', {
+    title: 'Get test plan test cases with steps by ID',
+    description: 'Get test cases belonging to a Targetprocess Test Plan by plan ID, including nested child test plans/containers and each test case steps.',
+    inputSchema: {
+        id: z.string()
+            .min(5)
+            .max(6)
+            .describe('Test plan ID (e.g. 145789)'),
+    },
+}, async ({ id }) => handleGetTestPlanTestCasesWithStepsById(tp, id));
+server.registerTool('get_test_case_by_id', {
+    title: 'Get test case by ID',
+    description: 'Get a single Targetprocess Test Case by its ID, including plain-text description and its steps.',
+    inputSchema: {
+        id: z.string()
+            .min(5)
+            .max(6)
+            .describe('Test case ID (e.g. 145789)'),
+    },
+}, async ({ id }) => handleGetTestCaseById(tp, id));
+server.registerTool('update_test_case_by_id', {
+    title: 'Update test case by ID',
+    description: 'Update a Targetprocess Test Case by its ID. Supports name and description only.',
+    inputSchema: {
+        id: z.string()
+            .min(5)
+            .max(6)
+            .describe('Test case ID (e.g. 145789)'),
+        name: z.string()
+            .optional()
+            .describe('Updated test case name'),
+        description: z.string()
+            .optional()
+            .describe('Updated test case description (format as HTML or plain text)'),
+    },
+}, async ({ id, name, description }) => handleUpdateTestCaseById(tp, { id, name, description }));
+server.registerTool('add_test_case_step_by_id', {
+    title: 'Add test case step by test case ID',
+    description: 'Add a new step to a Targetprocess Test Case. Despite tool name consistency, this takes testCaseId, not a step ID.',
+    inputSchema: {
+        testCaseId: z.string()
+            .min(5)
+            .max(6)
+            .describe('Test case ID to append the step to (e.g. 145789)'),
+        description: z.string()
+            .describe('Step action text'),
+        result: z.string()
+            .describe('Expected result for this step'),
+    },
+}, async ({ testCaseId, description, result }) => handleAddTestCaseStepById(tp, { testCaseId, description, result }));
+server.registerTool('update_test_case_step_by_id', {
+    title: 'Update test case step by ID',
+    description: 'Update a Targetprocess Test Step by its ID. Supports description and result only.',
+    inputSchema: {
+        id: z.string()
+            .min(5)
+            .max(6)
+            .describe('Test step ID (e.g. 145789)'),
+        description: z.string()
+            .optional()
+            .describe('Updated step action text'),
+        result: z.string()
+            .optional()
+            .describe('Updated expected result for this step'),
+    },
+}, async ({ id, description, result }) => handleUpdateTestCaseStepById(tp, { id, description, result }));
+server.registerTool('delete_test_case_step_by_id', {
+    title: 'Delete test case step by ID',
+    description: 'Delete a Targetprocess Test Step by its ID.',
+    inputSchema: {
+        id: z.string()
+            .min(5)
+            .max(6)
+            .describe('Test step ID (e.g. 145789)'),
+    },
+}, async ({ id }) => handleDeleteTestCaseStepById(tp, id));
 async function main() {
     const transport = new StdioServerTransport();
     await server.connect(transport);

package/build/tp.js

@@ -131,6 +131,35 @@ export class TpClient {
             return { ok: false, status: 0, body: String(error) };
         }
     }
+    async getAllOrNull(params) {
+        const allItems = [];
+        let skip = 0;
+        const take = 100;
+        while (true) {
+            const page = await this.get({
+                ...params,
+                param: {
+                    ...params.param,
+                    take,
+                    skip,
+                },
+            });
+            if (!page)
+                return null;
+            if (!page?.Items?.length)
+                break;
+            allItems.push(...page.Items);
+            if (!page.Next)
+                break;
+            skip += take;
+        }
+        return allItems;
+    }
+    /**
+     * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+     * TP
+     * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+     */
     async getUserStory(userStoryId) {
         const response = await this.get({
             pathParam: ["userStories", userStoryId],
@@ -518,7 +547,7 @@ export class TpClient {
             param: {
                 "where": `Description contains '${text}' and EntityState.Name eq 'Done'`,
                 "format": "json",
-                "take": "50",
+                "take": "100",
             },
         });
     }
@@ -531,7 +560,7 @@ export class TpClient {
             },
         });
     }
-    async getReleaseUserStories({ name, results = 50, withDescription = false }) {
+    async getReleaseUserStories({ name, results = 100, withDescription = false }) {
         const includeFilter = withDescription ? "[Name, Description, Id]" : "[Name, Id]";
         return this.get({
             pathParam: ["UserStories"],
@@ -543,7 +572,7 @@ export class TpClient {
             }
         });
     }
-    async getReleaseOpenUserStories({ name, results = 100, withDescription = false }) {
+    async getReleaseOpenUserStories({ name, results = 300, withDescription = false }) {
         const includeFilter = withDescription ? "[Name, Description, Id]" : "[Name, Id]";
         return this.get({
             pathParam: ["UserStories"],
@@ -555,7 +584,7 @@ export class TpClient {
             }
         });
     }
-    async getReleaseOpenBugs({ name, results = 200, withDescription = false }) {
+    async getReleaseOpenBugs({ name, results = 300, withDescription = false }) {
         const includeFilter = withDescription ? "[Name, Description, Id]" : "[Name, Id]";
         return this.get({
             pathParam: ["Bugs"],
@@ -579,7 +608,7 @@ export class TpClient {
             }
         });
     }
-    async getReleaseFeatures({ name, results = 50, withDescription = false }) {
+    async getReleaseFeatures({ name, results = 100, withDescription = false }) {
         const includeFilter = withDescription ? "[Name, Description, Id]" : "[Name, Id]";
         return this.get({
             pathParam: ["Features"],
@@ -644,6 +673,79 @@ export class TpClient {
             },
         });
     }
+    toTestPlanNode(testPlan, fallbackId) {
+        const id = testPlan?.Id ?? fallbackId;
+        if (id === undefined || id === null)
+            return null;
+        const numericId = Number(id);
+        return {
+            id: String(id),
+            numericId: Number.isNaN(numericId) ? 0 : numericId,
+            name: testPlan?.Name,
+        };
+    }
+    async getDirectTestPlanTestCaseItems(testPlan) {
+        const items = await this.getAllOrNull({
+            pathParam: ["testPlans", testPlan.id, "testcases"],
+            param: { "format": "json" },
+        });
+        if (!items)
+            return null;
+        return items.map((item) => ({
+            ...item,
+            TestPlanId: testPlan.numericId,
+            TestPlanName: testPlan.name || item.LinkedTestPlan?.Name,
+        }));
+    }
+    async getChildTestPlanNodes(testPlanId) {
+        const items = await this.getAllOrNull({
+            pathParam: ["testPlans"],
+            param: {
+                "format": "json",
+                "where": `ParentTestPlans.Id eq ${testPlanId}`,
+                "include": "[Id,Name,ParentTestPlans[Id,Name]]",
+            },
+        });
+        if (!items)
+            return null;
+        return items
+            .map((item) => this.toTestPlanNode(item))
+            .filter((item) => Boolean(item));
+    }
+    async getIndirectTestPlanTestCases(testPlanId) {
+        const rootTestPlan = await this.getTestPlan(testPlanId);
+        const rootTestPlanNode = this.toTestPlanNode(rootTestPlan, testPlanId);
+        if (!rootTestPlanNode)
+            return null;
+        const queue = [rootTestPlanNode];
+        const visitedPlanIds = new Set();
+        const seenTestCaseIds = new Set();
+        const testCases = [];
+        while (queue.length > 0) {
+            const testPlan = queue.shift();
+            if (visitedPlanIds.has(testPlan.id))
+                continue;
+            visitedPlanIds.add(testPlan.id);
+            const directTestCases = await this.getDirectTestPlanTestCaseItems(testPlan);
+            if (!directTestCases)
+                return null;
+            for (const testCase of directTestCases) {
+                const testCaseId = String(testCase.Id);
+                if (seenTestCaseIds.has(testCaseId))
+                    continue;
+                seenTestCaseIds.add(testCaseId);
+                testCases.push(testCase);
+            }
+            const childTestPlans = await this.getChildTestPlanNodes(testPlan.id);
+            if (!childTestPlans)
+                return null;
+            for (const childTestPlan of childTestPlans) {
+                if (!visitedPlanIds.has(childTestPlan.id))
+                    queue.push(childTestPlan);
+            }
+        }
+        return { Next: "", Items: testCases };
+    }
     async getTestPlanTestCases(testPlanId) {
         return this.get({
             pathParam: ["testPlans", testPlanId, "testcases"],
@@ -656,6 +758,46 @@ export class TpClient {
             param: { "format": "json" },
         });
     }
+    async getTestCase(testCaseId) {
+        return this.get({
+            pathParam: ["testCases", testCaseId],
+            param: { "format": "json" },
+        });
+    }
+    async updateTestCase({ id, name, description }) {
+        const testCase = { "Id": id };
+        if (name !== undefined)
+            testCase["Name"] = name;
+        if (description !== undefined)
+            testCase["Description"] = description;
+        return this.post({
+            pathParam: ["testCases"],
+            param: { "format": "json" },
+        }, testCase);
+    }
+    async getTestStep(testStepId) {
+        return this.get({
+            pathParam: ["testSteps", testStepId],
+            param: { "format": "json" },
+        });
+    }
+    async updateTestStep({ id, description, result }) {
+        const testStep = { "Id": id };
+        if (description !== undefined)
+            testStep["Description"] = description;
+        if (result !== undefined)
+            testStep["Result"] = result;
+        return this.post({
+            pathParam: ["testSteps"],
+            param: { "format": "json" },
+        }, testStep);
+    }
+    async deleteTestStep(testStepId) {
+        return this.del({
+            pathParam: ["testSteps", testStepId],
+            param: { "format": "json" },
+        });
+    }
     async getProjects() {
         return this.get({
             pathParam: ["Projects"],
@@ -943,6 +1085,12 @@ export class TpClient {
             param: { "format": "json" },
         });
     }
+    async getTestPlan(testPlanId) {
+        return this.get({
+            pathParam: ["testPlans", testPlanId],
+            param: { "format": "json" },
+        });
+    }
     async addAttachedFile(generalId, source) {
         let blob;
         let fileName;

package/package.json

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