npm - targetprocess-mcp-server - Versions diffs - 2.4.4 → 2.5.1 - Mend

targetprocess-mcp-server 2.4.4 → 2.5.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (8) hide show

package/README.md +8 -0
package/build/handlers/create_epic.js +14 -0
package/build/handlers/get_epic_content.js +38 -0
package/build/handlers/get_epic_features.js +24 -0
package/build/handlers/update_epic.js +14 -0
package/build/index.js +82 -2
package/build/tp.js +81 -1
package/package.json +1 -1

package/README.md CHANGED Viewed

@@ -96,6 +96,9 @@ Cards — Write
 > `projectId` and `teamId` are optional — fall back to `TP_PROJECT_ID` and `TP_TEAM_ID` from config
 - `format_existing_user_story` — Re-format the description of an existing user story using the structured template (id, header object with asA/iWant/soThat, acceptanceCriteria array, scenarios array with Gherkin steps, optional title, definitions, examplesTable, edgeCases, references, notes)
   > Call `get_user_story_content` first to read the current content, then reconstruct the structured fields before calling this tool
+- `get_epic_content` — Get a Targetprocess Epic by ID, including description, state, and progress (id)
+- `update_epic` — Update an epic's title, description, release, or project (id, optional title, optional description, optional releaseId, optional projectId)
+- `get_epic_features` — Get all features belonging to an epic (id)
 - `create_feature` — Create a new feature (title, optional description, optional epicId, optional releaseId, optional projectId, optional teamId)
 > [!NOTE]
 > `projectId` and `teamId` are optional — fall back to `TP_PROJECT_ID` and `TP_TEAM_ID` from config
@@ -129,6 +132,11 @@ Time Tracking
 - `log_time` — Log time spent on a Task, User Story, or Bug (entityId, entityType: Task | UserStory | Bug, hours, optional description, optional date)
 - `get_my_time_logs` — Get recent time log entries submitted by the current user (optional take)
+Assignments
+- `assign_role` — Assign a user to a role (e.g. Business Analyst, Developer, QA Engineer) on a TP card (cardId, userId, roleId)
+- `assign_role_to_feature` — Assign a user to a role on all user stories in a feature in one call (featureId, userId, roleId)
+- `get_assignment_roles` — List all available assignment roles with their IDs
 Developer Tools
 - `get_commit_message` — Returns a formatted commit message string for a task or bug ID (id, type: task | bug)
   > Format for task on a user story: `F#<featureId> US#<userStoryId> T#<taskId> <title>`

package/build/handlers/create_epic.js ADDED Viewed

@@ -0,0 +1,14 @@
+export async function handleCreateEpic(tp, params) {
+    const response = await tp.createEpic(params);
+    if (!response) {
+        return {
+            content: [{
+                    type: 'text',
+                    text: `Failed to create epic "${params.title}"\n JSON: ${JSON.stringify(response, null, 2)}`
+                }],
+        };
+    }
+    return {
+        content: [{ type: 'text', text: JSON.stringify(response) }],
+    };
+}

package/build/handlers/get_epic_content.js ADDED Viewed

@@ -0,0 +1,38 @@
+import { JSDOM } from 'jsdom';
+export async function handleGetEpicContent(tp, id) {
+    const epic = await tp.getEpic(id);
+    if (!epic) {
+        return {
+            content: [{
+                    type: 'text',
+                    text: `Failed to get epic, id: ${id}\n JSON: ${JSON.stringify(epic, null, 2)}`
+                }],
+        };
+    }
+    const result = {
+        name: epic.Name,
+        id: epic.Id,
+        description: '',
+        entityState: epic.EntityState?.Name,
+        release: epic.Release?.Name,
+        portfolioEpic: epic.PortfolioEpic?.Name,
+        progress: epic.Progress,
+        effort: epic.Effort,
+        customFields: epic.CustomFields,
+    };
+    const description = epic.Description || '';
+    if (description) {
+        try {
+            const dom = new JSDOM(`<html><body><div id="content">${description}</div></body></html>`);
+            const text = dom.window.document.getElementById('content')?.textContent;
+            if (text)
+                result.description = text;
+        }
+        catch (error) {
+            console.error('Error parsing epic description:', error);
+        }
+    }
+    return {
+        content: [{ type: 'text', text: JSON.stringify(result) }],
+    };
+}

package/build/handlers/get_epic_features.js ADDED Viewed

@@ -0,0 +1,24 @@
+export async function handleGetEpicFeatures(tp, epicId) {
+    const response = await tp.getEpicFeatures(epicId);
+    if (!response) {
+        return {
+            content: [{
+                    type: 'text',
+                    text: `Failed to get features for epic id: ${epicId}`
+                }],
+        };
+    }
+    const features = response.Items ?? [];
+    const result = features.map(f => ({
+        id: f.Id,
+        name: f.Name,
+        entityState: f.EntityState?.Name,
+        team: f.Team?.Name,
+        release: f.Release?.Name,
+        progress: f.Progress,
+        effort: f.Effort,
+    }));
+    return {
+        content: [{ type: 'text', text: JSON.stringify({ total: result.length, features: result }) }],
+    };
+}

package/build/handlers/update_epic.js ADDED Viewed

@@ -0,0 +1,14 @@
+export async function handleUpdateEpic(tp, params) {
+    const response = await tp.updateEpic(params);
+    if (!response) {
+        return {
+            content: [{
+                    type: 'text',
+                    text: `Failed to update epic id: ${params.id}\n JSON: ${JSON.stringify(response, null, 2)}`
+                }],
+        };
+    }
+    return {
+        content: [{ type: 'text', text: JSON.stringify(response) }],
+    };
+}

package/build/index.js CHANGED Viewed

@@ -2,6 +2,7 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { z } from "zod";
 import { JSDOM } from "jsdom";
+import { createRequire } from "module";
 import { TpClient } from "./tp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { config } from "./config.js";
@@ -25,6 +26,10 @@ import { handleGetBugComments } from "./handlers/get_bug_comments.js";
 import { handleCreateBug } from "./handlers/create_bug.js";
 import { handleCreateUserStory } from "./handlers/create_user_story.js";
 import { handleCreateFeature } from "./handlers/create_feature.js";
+import { handleCreateEpic } from "./handlers/create_epic.js";
+import { handleGetEpicContent } from "./handlers/get_epic_content.js";
+import { handleUpdateEpic } from "./handlers/update_epic.js";
+import { handleGetEpicFeatures } from "./handlers/get_epic_features.js";
 import { handleCreateTask } from "./handlers/create_task.js";
 import { handleUpdateBug } from "./handlers/update_bug.js";
 import { handleGetInProgressTasksAndBugs } from "./handlers/get_in_progress_tasks_and_bugs.js";
@@ -474,9 +479,12 @@ server.registerTool('update_user_story', {
         entityStateId: z.string()
             .optional()
             .describe('Optional Entity State ID — if user gave a state name, resolve it via "get_user_story_workflows" first'),
+        featureId: z.string()
+            .optional()
+            .describe('Optional Feature ID — moves this user story to the specified feature'),
     },
-}, async ({ id, title, description, projectId, teamId, entityStateId }) => {
-    const response = await tp.updateUserStory({ id, title, description, projectId, teamId, entityStateId });
+}, async ({ id, title, description, projectId, teamId, entityStateId, featureId }) => {
+    const response = await tp.updateUserStory({ id, title, description, projectId, teamId, entityStateId, featureId });
     if (!response) {
         return {
             content: [{
@@ -718,6 +726,69 @@ server.registerTool('create_feature', {
             .describe('Optional Team ID — defaults to TP_TEAM_ID from config'),
     },
 }, async ({ title, description, epicId, releaseId, projectId, teamId }) => handleCreateFeature(tp, { title, description, epicId, releaseId, projectId, teamId }));
+server.registerTool('create_epic', {
+    title: 'Create a new epic',
+    description: `Create a new Epic in Targetprocess.`,
+    inputSchema: {
+        title: z.string()
+            .describe('Epic title'),
+        description: z.string()
+            .optional()
+            .describe('Optional epic description (when provided, format as HTML)'),
+        releaseId: z.string()
+            .min(5)
+            .max(6)
+            .optional()
+            .describe('Optional Release ID to link this epic to (e.g. 145200)'),
+        projectId: z.string()
+            .optional()
+            .describe('Optional Project ID -- defaults to TP_PROJECT_ID from config'),
+    },
+}, async ({ title, description, releaseId, projectId }) => handleCreateEpic(tp, { title, description, releaseId, projectId }));
+server.registerTool('get_epic_content', {
+    title: 'Get epic content',
+    description: 'Get a Targetprocess Epic by ID, including its description, state, and progress.',
+    inputSchema: {
+        id: z.string()
+            .min(5)
+            .max(6)
+            .describe('Epic ID (e.g. 148813)'),
+    },
+}, async ({ id }) => handleGetEpicContent(tp, id));
+server.registerTool('update_epic', {
+    title: 'Update an epic',
+    description: 'Update a Targetprocess Epic. Pass only the fields to change.',
+    inputSchema: {
+        id: z.string()
+            .min(5)
+            .max(6)
+            .describe('Epic ID (e.g. 148813)'),
+        title: z.string()
+            .optional()
+            .describe('Updated epic title'),
+        description: z.string()
+            .optional()
+            .describe('Updated epic description (format as HTML)'),
+        releaseId: z.string()
+            .min(5)
+            .max(6)
+            .optional()
+            .describe('Optional Release ID to link this epic to'),
+        projectId: z.string()
+            .optional()
+            .describe('Optional Project ID'),
+    },
+}, async ({ id, title, description, releaseId, projectId }) => handleUpdateEpic(tp, { id, title, description, releaseId, projectId }));
+server.registerTool('get_epic_features', {
+    title: 'Get features in an epic',
+    description: 'Get all Features belonging to a Targetprocess Epic.',
+    inputSchema: {
+        id: z.string()
+            .min(5)
+            .max(6)
+            .describe('Epic ID (e.g. 148813)'),
+    },
+}, async ({ id }) => handleGetEpicFeatures(tp, id));
 server.registerTool('create_test_plan', {
     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.`,
@@ -1380,6 +1451,15 @@ server.registerTool('get_my_time_logs', {
             .describe('Number of entries to return, default is 25'),
     },
 }, async ({ take }) => handleGetMyTimeLogs(tp, take));
+const require = createRequire(import.meta.url);
+const { version } = require("../package.json");
+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 function main() {
     const transport = new StdioServerTransport();
     await server.connect(transport);

package/build/tp.js CHANGED Viewed

@@ -197,7 +197,7 @@ export class TpClient {
             param: { "format": "json" },
         }, userStory);
     }
-    async updateUserStory({ id, title, description, projectId, teamId, entityStateId }) {
+    async updateUserStory({ id, title, description, projectId, teamId, entityStateId, featureId }) {
         const userStory = { "Id": id };
         if (title)
             userStory["Name"] = title;
@@ -209,6 +209,8 @@ export class TpClient {
             userStory["assignedTeams"] = [{ "team": { "id": teamId } }];
         if (entityStateId)
             userStory["EntityState"] = { "Id": entityStateId };
+        if (featureId)
+            userStory["Feature"] = { "Id": featureId };
         return this.post({
             pathParam: ["UserStories"],
             param: { "format": "json" },
@@ -283,6 +285,52 @@ export class TpClient {
             param: { "format": "json" },
         }, userStory);
     }
+    async getEpic(epicId) {
+        return this.get({
+            pathParam: ["Epics", epicId],
+            param: { "format": "json" },
+        });
+    }
+    async updateEpic({ id, title, description, releaseId, projectId }) {
+        const epic = { "Id": id };
+        if (title)
+            epic["Name"] = title;
+        if (description)
+            epic["Description"] = description;
+        if (projectId)
+            epic["Project"] = { "Id": projectId };
+        if (releaseId)
+            epic["Release"] = { "Id": releaseId };
+        return this.post({
+            pathParam: ["Epics"],
+            param: { "format": "json" },
+        }, epic);
+    }
+    async getEpicFeatures(epicId) {
+        return this.get({
+            pathParam: ["Features"],
+            param: {
+                "format": "json",
+                "where": `Epic.Id eq ${epicId}`,
+                "include": "[Id,Name,Description,EntityState[Name],Team[Name],Release[Name],Progress,Effort]",
+                "take": 100,
+            },
+        });
+    }
+    async createEpic({ title, description, releaseId, projectId }) {
+        const epic = {
+            "Name": title,
+            "Project": { "Id": projectId || config.tp.projectId },
+        };
+        if (description)
+            epic["Description"] = description;
+        if (releaseId)
+            epic["Release"] = { "Id": releaseId };
+        return this.post({
+            pathParam: ["Epics"],
+            param: { "format": "json" },
+        }, epic);
+    }
     async createFeature({ title, description, epicId, releaseId, projectId, teamId }) {
         const feature = {
             "Name": title,
@@ -772,6 +820,38 @@ export class TpClient {
             param: { "format": "json" },
         }, body);
     }
+    async assignRole(cardId, userId, roleId) {
+        return this.post({
+            pathParam: ["Assignments"],
+            param: { "format": "json" },
+        }, {
+            Assignable: { Id: parseInt(cardId) },
+            GeneralUser: { Id: parseInt(userId) },
+            Role: { Id: parseInt(roleId) },
+        });
+    }
+    async assignRoleToAllStoriesInFeature(featureId, userId, roleId) {
+        const storiesResponse = await this.getFeatureUserStories(featureId);
+        const storyItems = storiesResponse?.items?.[0]?.userStories?.items ?? [];
+        const succeeded = [];
+        const failed = [];
+        await Promise.all(storyItems.map(async (story) => {
+            const result = await this.assignRole(String(story.id), userId, roleId);
+            if (result) {
+                succeeded.push(result);
+            }
+            else {
+                failed.push(story.id);
+            }
+        }));
+        return { succeeded, failed };
+    }
+    async getAssignmentRoles() {
+        return this.get({
+            pathParam: ["Roles"],
+            param: { "format": "json" },
+        });
+    }
     async getMyTimeLogs(take = 25) {
         return this.get({
             pathParam: ["Times"],

package/package.json CHANGED Viewed

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