targetprocess-mcp-server 1.0.1

package/README.md

@@ -0,0 +1,83 @@
+# Targetprocess MCP Server
+
+An **MCP (Model Context Protocol) server** that enables AI assistants to interact with the **Targetprocess** project management platform through structured tools and natural language workflows.
+
+This server exposes powerful capabilities for querying, creating, and managing Targetprocess entities such as user stories, bugs, tasks, and features.
+
+It acts as a **bridge between LLM agents and the Targetprocess API**, providing:
+
+- Structured **tool-based access**
+- Semantic, natural-language-driven workflows
+
+---
+
+## Features
+  - Create Bugs based on user story
+  - Retreive TP entities: bugs, user stories
+
+- **LLM-Friendly Tools**
+  - Designed for Claude MCP AI agents
+
+---
+
+## Use Cases examples:
+
+- "Show me currently active release"
+- "write me test cases based on 145322 tp user story"
+- "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"
+
+- "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
+
+---
+
+## Installation
+### Local
+```json
+{
+  "mcpServers": {
+    "targetprocess": {
+      "command": "/Users/mcs/.config/nvm/versions/node/v22.14.0/bin/node",
+      "args": [
+        "/path/to/repository"
+      ],
+      "env": {
+        "TP_TOKEN": "<your-tp-token>" // Settings -> Authentication and Security -> New Access Token,
+        "TP_BASE_URL": "<tp-api-endpoint>",
+        "TP_API_VERSION": "v1",
+        "TP_OWNER_ID": "<tp-owner-id>", // your user id
+        "TP_PROJECT_ID": "<tp-project-id>",
+        "TP_TEAM_ID": "<tp-team-id>"
+      }
+    }
+}
+```
+### From Repository
+```json
+{
+  "mcpServers": {
+    "github": {
+      "command": "https://github.com/SerhiiMaksymiv/targetprocess-mcp-server.git",
+      "env": {
+        "GITHUB_PERSONAL_ACCESS_TOKEN": "your_github_token_here",
+        ...
+        "TP_TEAM_ID": ...
+      }
+    }
+  }
+}
+
+```
+
+## Local Development
+```
+git clone --recursive https://github.com/SerhiiMaksymiv/targetprocess-mcp-server.git
+cd targetprocess-mcp-server
+
+npm install
+npm run build
+```

package/build/src/config.js

@@ -0,0 +1,10 @@
+import "dotenv/config";
+export const config = {
+    tp: {
+        url: process.env.TP_BASE_URL || "",
+        token: process.env.TP_TOKEN || "",
+        ownerId: process.env.TP_OWNER_ID || "",
+        projectId: process.env.TP_PROJECT_ID || "",
+        teamId: process.env.TP_TEAM_ID || "",
+    }
+};

package/build/src/index.js

@@ -0,0 +1,517 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+import { JSDOM } from "jsdom";
+import { TpClient } from "./tp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+const server = new McpServer({
+    name: "tp",
+    version: "1.0.0"
+}, {
+    capabilities: {
+        "tools": {
+            "listChanged": true
+        },
+        "prompts": {
+            "listChanged": true
+        },
+        "resources": {
+            "subscribe": true,
+            "listChanged": true
+        }
+    }
+});
+const tp = new TpClient();
+server.registerTool('get_user_story_content', {
+    title: 'Get TP user story content',
+    description: 'Get tp card (user story) content by specified id, e.g. 145789',
+    inputSchema: {
+        id: z.string()
+            .min(5)
+            .max(6)
+            .describe('TP (or tp) ID (e.g. 145789)')
+    },
+}, async ({ id }) => {
+    const userStory = await tp.getUserStory(id);
+    if (!userStory) {
+        return {
+            content: [{
+                    type: 'text',
+                    text: `Failed to get user story, id: ${id}\n JSON: ${JSON.stringify(userStory, null, 2)}`
+                }],
+        };
+    }
+    const description = userStory.Description || '';
+    if (!description) {
+        return {
+            content: [{
+                    type: "text",
+                    text: `No description for ${id} tp card`,
+                }],
+        };
+    }
+    const dom = new JSDOM(`<html><body><div id="content">${description}</div></body></html>`);
+    const descriptionText = dom.window.document.getElementById('content')?.textContent;
+    return {
+        content: [{
+                type: 'text',
+                text: JSON.stringify(descriptionText)
+            }],
+    };
+});
+server.registerTool('get_current_releases', {
+    title: 'Get current releases',
+    description: 'Get current releases',
+}, async ({}) => {
+    const releases = await tp.getCurrentReleases();
+    if (!releases) {
+        return {
+            content: [{
+                    type: 'text',
+                    text: `Failed to get current releases, JSON: ${JSON.stringify(releases, null, 2)}`
+                }],
+        };
+    }
+    const items = releases.Items || [];
+    if (items.length == 0) {
+        return {
+            content: [{
+                    type: "text",
+                    text: `No releases found`,
+                }],
+        };
+    }
+    return {
+        content: [{
+                type: 'text',
+                text: JSON.stringify(items)
+            }],
+    };
+});
+server.registerTool('get_release_user_stories', {
+    title: 'Get release user stories',
+    description: 'Get release user stories',
+    inputSchema: {
+        name: z.string()
+            .describe('Release name'),
+        results: z.number()
+            .default(50)
+            .optional()
+            .describe('Number of results to return, default is 50'),
+    },
+}, async ({ name, results }) => {
+    const release = await tp.getReleaseUserStories({ name, results });
+    if (!release) {
+        return {
+            content: [{
+                    type: 'text',
+                    text: `Failed to get ${name} release user stories, JSON: ${JSON.stringify(release, null, 2)}`
+                }],
+        };
+    }
+    const items = release.Items || [];
+    if (items.length == 0) {
+        return {
+            content: [{
+                    type: "text",
+                    text: `No release user stories found`,
+                }],
+        };
+    }
+    return {
+        content: [{
+                type: 'text',
+                text: JSON.stringify(items)
+            }],
+    };
+});
+server.registerTool('get_release_bugs', {
+    title: 'Get release bugs',
+    description: 'Get release bugs',
+    inputSchema: {
+        name: z.string()
+            .describe('Release name'),
+        results: z.number()
+            .default(100)
+            .optional()
+            .describe('Number of results to return, default is 100'),
+    },
+}, async ({ name, results }) => {
+    const release = await tp.getReleaseBugs({ name, results });
+    if (!release) {
+        return {
+            content: [{
+                    type: 'text',
+                    text: `Failed to get ${name} release bugs, JSON: ${JSON.stringify(release, null, 2)}`
+                }],
+        };
+    }
+    const items = release.Items || [];
+    if (items.length == 0) {
+        return {
+            content: [{
+                    type: "text",
+                    text: `No release bugs found`,
+                }],
+        };
+    }
+    return {
+        content: [{
+                type: 'text',
+                text: JSON.stringify(items)
+            }],
+    };
+});
+server.registerTool('get_release_features', {
+    title: 'Get release features',
+    description: 'Get release features',
+    inputSchema: {
+        name: z.string()
+            .describe('Release name'),
+        results: z.number()
+            .default(50)
+            .optional()
+            .describe('Number of results to return, default is 100'),
+    },
+}, async ({ name, results }) => {
+    const release = await tp.getReleaseFeatures({ name, results });
+    if (!release) {
+        return {
+            content: [{
+                    type: 'text',
+                    text: `Failed to get ${name} release features, JSON: ${JSON.stringify(release, null, 2)}`
+                }],
+        };
+    }
+    const items = release.Items || [];
+    if (items.length == 0) {
+        return {
+            content: [{
+                    type: "text",
+                    text: `No release features found`,
+                }],
+        };
+    }
+    return {
+        content: [{
+                type: 'text',
+                text: JSON.stringify(items)
+            }],
+    };
+});
+server.registerTool('get_release_user_stories_with_description', {
+    title: 'Get release user stories with description',
+    description: `Get release user stories with description in the response.
+      Note: this is slower than "get_release_user_stories_names" tool,
+      but if user wants to get descriptions, then this tool is the way to go.
+    `,
+    inputSchema: {
+        name: z.string()
+            .describe('Release name'),
+        withDescription: z.boolean()
+            .describe('Include description in the response'),
+    },
+}, async ({ name, withDescription }) => {
+    const release = await tp.getReleaseUserStories({ name, withDescription });
+    if (!release) {
+        return {
+            content: [{
+                    type: 'text',
+                    text: `Failed to get ${name} release user stories, JSON: ${JSON.stringify(release, null, 2)}`
+                }],
+        };
+    }
+    const items = release.Items || [];
+    if (items.length == 0) {
+        return {
+            content: [{
+                    type: "text",
+                    text: `No release user stories found`,
+                }],
+        };
+    }
+    return {
+        content: [{
+                type: 'text',
+                text: JSON.stringify(items)
+            }],
+    };
+});
+server.registerTool('get_release_open_bugs', {
+    title: 'Get release active bugs',
+    description: `Get release active bugs (bugs that are not closed, done, passed, ready to deploy)`,
+    inputSchema: {
+        name: z.string()
+            .describe('Release name'),
+        results: z.number()
+            .default(200)
+            .optional()
+            .describe('Number of results to return, default is 50'),
+        withDescription: z.boolean()
+            .describe('Include description in the response'),
+    },
+}, async ({ name, results, withDescription }) => {
+    const release = await tp.getReleaseOpenBugs({ name, results, withDescription });
+    if (!release) {
+        return {
+            content: [{
+                    type: 'text',
+                    text: `Failed to get ${name} release bugs, JSON: ${JSON.stringify(release, null, 2)}`
+                }],
+        };
+    }
+    const items = release.Items || [];
+    if (items.length == 0) {
+        return {
+            content: [{
+                    type: "text",
+                    text: `No release bugs found`,
+                }],
+        };
+    }
+    return {
+        content: [{
+                type: 'text',
+                text: JSON.stringify(items)
+            }],
+    };
+});
+server.registerTool('get_release_open_user_stories', {
+    title: 'Get release active user stories',
+    description: `Get release active user stories (user stories that are not closed, done, passed, ready to deploy)`,
+    inputSchema: {
+        name: z.string()
+            .describe('Release name'),
+        results: z.number()
+            .default(100)
+            .optional()
+            .describe('Number of results to return, default is 50'),
+        withDescription: z.boolean()
+            .describe('Include description in the response'),
+    },
+}, async ({ name, results, withDescription }) => {
+    const release = await tp.getReleaseOpenUserStories({ name, results, withDescription });
+    if (!release) {
+        return {
+            content: [{
+                    type: 'text',
+                    text: `Failed to get ${name} release user stories, JSON: ${JSON.stringify(release, null, 2)}`
+                }],
+        };
+    }
+    const items = release.Items || [];
+    if (items.length == 0) {
+        return {
+            content: [{
+                    type: "text",
+                    text: `No release user stories found`,
+                }],
+        };
+    }
+    return {
+        content: [{
+                type: 'text',
+                text: JSON.stringify(items)
+            }],
+    };
+});
+server.registerTool('search_all_cards_by_keyword', {
+    title: 'Search TP cards (user stories, bugs, features) by keyword or partial name',
+    description: `Searches tp cards (user stories, bugs, features) by keyword or partial name or partial keyphrase e.g. "Text Element"`,
+    inputSchema: {
+        keyword: z.string()
+            .describe('Keyword or partial name or keyphrase to search for'),
+    },
+}, async ({ keyword }) => {
+    const results = await Promise.all([
+        tp.searchContainsNameText({ text: keyword, entityType: "UserStories" }),
+        tp.searchContainsNameText({ text: keyword, entityType: "Bugs" }),
+        tp.searchContainsNameText({ text: keyword, entityType: "Features" }),
+    ]);
+    const generalResults = results.map((item) => item.Items).flat();
+    if (!generalResults) {
+        return {
+            content: [{
+                    type: 'text',
+                    text: `Failed to find card by keyword: "${keyword}"\n JSON: ${JSON.stringify(generalResults, null, 2)}`
+                }],
+        };
+    }
+    const items = generalResults || [];
+    if (items.length == 0) {
+        return {
+            content: [{
+                    type: "text",
+                    text: `No results for ${keyword}`,
+                }],
+        };
+    }
+    const parsedItems = items.map((item) => {
+        const dom = new JSDOM(`<html><body><div id="content">${item.Description}</div></body></html>`);
+        const descriptionText = dom.window.document.getElementById('content')?.textContent;
+        return {
+            title: item.Name,
+            id: item.Id,
+            description: descriptionText,
+        };
+    });
+    return {
+        content: [{
+                type: 'text',
+                text: JSON.stringify(parsedItems)
+            }],
+    };
+});
+server.registerTool('get_bug_content', {
+    title: 'Get TP bug content',
+    description: 'Get tp card (bug) content by specified id, e.g. 145789',
+    inputSchema: {
+        id: z.string()
+            .min(5)
+            .max(6)
+            .describe('Bug card ID (e.g. 145789)')
+    },
+}, async ({ id }) => {
+    const bug = await tp.getBug(id);
+    if (!bug) {
+        return {
+            content: [{
+                    type: 'text',
+                    text: `Failed to get bug, id: ${id}\n JSON: ${JSON.stringify(bug, null, 2)}`
+                }],
+        };
+    }
+    const description = bug.Description || '';
+    if (!description) {
+        return {
+            content: [{
+                    type: "text",
+                    text: `No description for ${id} tp card`,
+                }],
+        };
+    }
+    const dom = new JSDOM(`<html><body><div id="content">${description}</div></body></html>`);
+    const descriptionText = dom.window.document.getElementById('content')?.textContent;
+    return {
+        content: [{
+                type: 'text',
+                text: JSON.stringify(descriptionText)
+            }],
+    };
+});
+server.registerTool('add_comment', {
+    title: 'Adds provided content to TP card (user story) as a comment',
+    description: `Adds provided content as a comment to the specified tp card by id, e.g. 145789`,
+    inputSchema: {
+        id: z.string()
+            .min(5)
+            .max(6)
+            .describe('TP card id, usually user story or bug ID (e.g. 145789)'),
+        comment: z.string()
+            .describe('Comment content to add'),
+    },
+}, async ({ id, comment }) => {
+    try {
+        const addCommentResponse = await tp.addComment(id, comment);
+        if (!addCommentResponse) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: `Failed to add comment to user story, id: ${id}\n JSON: ${JSON.stringify(addCommentResponse, null, 2)}`
+                    }]
+            };
+        }
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify(addCommentResponse)
+                }],
+        };
+    }
+    catch (error) {
+        console.error("Error adding comment to user story:", error);
+        return {
+            content: [{
+                    type: 'text',
+                    text: `Failed to add comment to user story, id: ${id}\n Error: ${error}`
+                }]
+        };
+    }
+});
+server.registerTool('create_bug', {
+    title: 'Create a new bug card based on provided card id',
+    description: `Create a new bug card based on provided card id that summarizes the problem in concise,
+      descriptive manner answering questions What? Where? When?,
+      and content explaining what happened in detail.
+      CRITICAL WORKFLOW: Before calling this tool, you MUST follow these steps: 
+        1) IF you already have user story or bug card content, proceed to step 3 skipping step 2;
+        2) ELSE call "get_user_story_content" tool or "get_bug_content" tool to get user story or bug card content;
+        3) format the new bug inside html <div> tags with Issue Description, Steps to Reproduce, Expected Behavior, Actual Behavior;
+        4) add a comment to the card with bug Id provided in the first step and Title`,
+    inputSchema: {
+        title: z.string()
+            .describe('Bug card title that summarizes the problem in concise, descriptive, and actionable manner, enabling a developer to understand the issue without opening the report'),
+        id: z.string()
+            .min(5)
+            .max(6)
+            .describe(`Usually user story id or bug ID (e.g. 145789)`),
+        bugContent: z.string()
+            .describe(`Comment content to add, explain what happened in detail.
+                  Include expected behaviour and what actually occurred.
+                  Be specific and avoid assumptions.
+                  Clearly outline the actions needed to trigger the bug.
+                  Number each step so anyone can follow them easily`),
+    },
+}, async ({ title, id, bugContent }) => {
+    const bugResponse = await tp.createBugBasedOnCardId(title, id, bugContent);
+    if (!bugResponse) {
+        return {
+            content: [{
+                    type: 'text',
+                    text: `Failed to create comment "${title}"\n JSON: ${JSON.stringify(bugResponse, null, 2)}`
+                }]
+        };
+    }
+    return {
+        content: [{
+                type: 'text',
+                text: JSON.stringify(bugResponse)
+            }],
+    };
+});
+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`,
+    inputSchema: {
+        title: z.string()
+            .describe(`Test plan title that is taken from user story title`),
+        userStoryId: z.string()
+            .min(5)
+            .max(6)
+            .describe(`User story id, usually user story or bug ID (e.g. 145789)`),
+    },
+}, async ({ title, userStoryId }) => {
+    const testPlanResponse = await tp.createTestPlan(title, userStoryId);
+    if (!testPlanResponse) {
+        return {
+            content: [{
+                    type: 'text',
+                    text: `Failed to create testPlanResponse "${title}"\n JSON: ${JSON.stringify(testPlanResponse, null, 2)}`
+                }]
+        };
+    }
+    return {
+        content: [{
+                type: 'text',
+                text: JSON.stringify(testPlanResponse)
+            }],
+    };
+});
+async function main() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error("Weather MCP Server running on stdio");
+}
+main().catch((error) => {
+    console.error("Fatal error in main():", error);
+    process.exit(1);
+});

package/build/src/tp.js

@@ -0,0 +1,268 @@
+import { config } from "./config.js";
+export class TpClient {
+    baseUrl = config.tp.url;
+    token = config.tp.token;
+    headers;
+    constructor() {
+        this.headers = {
+            "Content-Type": "application/json",
+            Accept: "application/json",
+        };
+    }
+    params(params) {
+        let _url = this.baseUrl;
+        for (const [key, value] of Object.entries(params.pathParam)) {
+            _url += value ? `/${key}/${value}` : `/${key}`;
+        }
+        let _urlParams = [];
+        for (const [key, value] of Object.entries(params.param)) {
+            _urlParams.push(`${key}=${encodeURIComponent(value)}`);
+        }
+        return _url + "/?" + _urlParams.join("&");
+    }
+    // @ts-ignore
+    async getAll(params) {
+        const allItems = [];
+        let skip = 0;
+        const take = 100;
+        while (true) {
+            params.param["take"] = take;
+            params.param["skip"] = skip;
+            const page = await this.get(params);
+            if (!page?.Items?.length)
+                break;
+            allItems.push(...page.Items);
+            if (!page.Next)
+                break;
+            skip += take;
+        }
+        return allItems;
+    }
+    async get(params) {
+        params.param["access_token"] = this.token;
+        let _url = this.params(params);
+        try {
+            const response = await fetch(_url, {
+                method: "GET",
+                headers: this.headers
+            });
+            if (!response.ok) {
+                throw new Error(`HTTP error! status: ${response.status}`);
+            }
+            return (await response.json());
+        }
+        catch (error) {
+            console.error("Error making TP request:", error);
+            console.error("Request URL:", _url);
+            return null;
+        }
+    }
+    async post(params, data) {
+        params.param["access_token"] = this.token;
+        let _url = this.params(params);
+        try {
+            const response = await fetch(_url, {
+                method: "POST",
+                headers: this.headers,
+                body: JSON.stringify(data),
+            });
+            if (!response.ok) {
+                throw new Error(`HTTP error! status: ${response.status}`);
+            }
+            return (await response.json());
+        }
+        catch (error) {
+            console.error("Error making TP request:", error);
+            return null;
+        }
+    }
+    async getUserStory(userStoryId) {
+        const response = await this.get({
+            pathParam: {
+                "userStories": userStoryId,
+            },
+            param: {
+                "format": "json",
+            }
+        });
+        return response;
+    }
+    async getBug(bugId) {
+        const response = await this.get({
+            pathParam: { "bugs": bugId },
+            param: { "format": "json" }
+        });
+        return response;
+    }
+    async createBug(title, bugContent) {
+        const bug = {
+            "Name": title,
+            "Project": {
+                "Id": 59901
+            },
+            "customFields": [{
+                    "name": "Origin",
+                    "type": "DropDown",
+                    "value": "Manual QA"
+                }],
+            "assignedTeams": [{
+                    "team": {
+                        "id": 127065
+                    }
+                }],
+            "Description": bugContent,
+        };
+        return this.post({
+            pathParam: { "bugs": '' },
+            param: { "format": "json" },
+        }, bug);
+    }
+    async createBugBasedOnCardId(title, userStoryId, bugContent) {
+        const bug = {
+            "Name": title,
+            "Project": {
+                "Id": 59901
+            },
+            "UserStory": {
+                "Id": userStoryId
+            },
+            "customFields": [{
+                    "name": "Origin",
+                    "type": "DropDown",
+                    "value": "Manual QA"
+                }],
+            "assignedTeams": [{
+                    "team": {
+                        "id": 127065
+                    }
+                }],
+            "Description": bugContent,
+        };
+        return this.post({
+            pathParam: { "bugs": '' },
+            param: { "format": "json" },
+        }, bug);
+    }
+    async createTestPlan(title, userStoryId) {
+        const testPlan = {
+            "Name": title,
+            "Project": {
+                "Id": 59901
+            },
+            "LinkedGeneral": {
+                "ResourceType": "General",
+                "Id": userStoryId,
+                "Name": title,
+            },
+            "LinkedAssignable": {
+                "ResourceType": "Assignable",
+                "Id": userStoryId,
+                "Name": title,
+            },
+            "LinkedUserStory": {
+                "ResourceType": "UserStory",
+                "Id": userStoryId,
+                "Name": title,
+            },
+        };
+        return this.post({
+            pathParam: { "testPlans": '' },
+            param: { "format": "json" },
+        }, testPlan);
+    }
+    async addComment(userStoryId, comment) {
+        const commentData = {
+            description: comment,
+            owner: {
+                id: "1504",
+            },
+            general: {
+                id: userStoryId,
+            },
+        };
+        return this.post({
+            pathParam: { "comments": '' },
+            param: { "format": "json" },
+        }, commentData);
+    }
+    async searchContainsNameText({ text, entityType }) {
+        return this.get({
+            pathParam: { [entityType]: '' },
+            param: {
+                "format": "json",
+                "take": "25",
+                "where": `Name contains '${text}'`,
+                "include": "[Name, Description, Id]"
+            },
+        });
+    }
+    async getCurrentReleases() {
+        return this.get({
+            pathParam: { "Releases": '' },
+            param: {
+                "format": "json",
+                "where": `IsCurrent eq 'true'`,
+            },
+        });
+    }
+    async getReleaseUserStories({ name, results = 50, withDescription = false }) {
+        const includeFilter = withDescription ? "[Name, Description, Id]" : "[Name, Id]";
+        return this.get({
+            pathParam: { "UserStories": '' },
+            param: {
+                "format": "json",
+                "take": results,
+                "where": `Release.Name eq '${name}'`,
+                "include": includeFilter,
+            }
+        });
+    }
+    async getReleaseOpenUserStories({ name, results = 100, withDescription = false }) {
+        const includeFilter = withDescription ? "[Name, Description, Id]" : "[Name, Id]";
+        return this.get({
+            pathParam: { "UserStories": '' },
+            param: {
+                "format": "json",
+                "take": results,
+                "where": `Release.Name eq '${name}' and EntityState.Name ne 'Closed' and EntityState.Name ne 'Done' and EntityState.Name ne 'Passed Dev01  QA' and EntityState.Name ne 'Ready to Deploy to prod'`,
+                "include": includeFilter,
+            }
+        });
+    }
+    async getReleaseOpenBugs({ name, results = 200, withDescription = false }) {
+        const includeFilter = withDescription ? "[Name, Description, Id]" : "[Name, Id]";
+        return this.get({
+            pathParam: { "Bugs": '' },
+            param: {
+                "format": "json",
+                "take": results,
+                "where": `Release.Name eq '${name}' and EntityState.Name ne 'Closed' and EntityState.Name ne 'Done' and EntityState.Name ne 'Passed Dev01  QA' and EntityState.Name ne 'Ready to Deploy to prod'`,
+                "include": includeFilter,
+            }
+        });
+    }
+    async getReleaseBugs({ name, results = 100, withDescription = false }) {
+        const includeFilter = withDescription ? "[Name, Description, Id]" : "[Name, Id]";
+        return this.get({
+            pathParam: { "Bugs": '' },
+            param: {
+                "format": "json",
+                "take": results,
+                "where": `Release.Name eq '${name}'`,
+                "include": includeFilter,
+            }
+        });
+    }
+    async getReleaseFeatures({ name, results = 50, withDescription = false }) {
+        const includeFilter = withDescription ? "[Name, Description, Id]" : "[Name, Id]";
+        return this.get({
+            pathParam: { "Features": '' },
+            param: {
+                "format": "json",
+                "take": results,
+                "where": `Release.Name eq '${name}'`,
+                "include": includeFilter,
+            }
+        });
+    }
+}

package/build/src/types.js

@@ -0,0 +1,7 @@
+/**
+ * Every file in src/mcps/ must export a default value matching this shape.
+ *
+ * The app mounts it at  POST /mcp/:name
+ * The manager connects to  http://localhost:{PORT}/mcp/:name
+ */
+export {};

package/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "targetprocess-mcp-server",
+  "type": "module",
+  "bin": {
+    "tp": "build/src/index.js"
+  },
+  "scripts": {
+    "prebuild": "rimraf build dist",
+    "build": "tsc",
+    "postbuild": "shx chmod +x build/**/*.js",
+    "prestart": "npm run build",
+    "start": "node build/src/main.js"
+  },
+  "files": [
+    "build"
+  ],
+  "publishConfig": {
+    "ignore": [
+      "!build/",
+      "src/",
+      "test/"
+    ]
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/SerhiiMaksymiv/targetprocess-mcp-server.git"
+  },
+  "engines": {
+    "node": ">=20.x"
+  },
+  "version": "1.0.1",
+  "description": "MCP server for Tartget Process",
+  "main": "build/src/index.js",
+  "keywords": [
+    "mcp",
+    "tp",
+    "mcp-server",
+    "targetprocess",
+    "targetprocess-server"
+  ],
+  "author": "Serhii Maksymiv",
+  "license": "ISC",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.26.0",
+    "zod": "^3.25.76",
+    "@types/node": "^25.2.2",
+    "dotenv": "^17.2.4",
+    "@types/jsdom": "^27.0.0",
+    "typescript": "^5.9.3",
+    "rimraf": "^6.1.2",
+    "shx": "^0.4.0",
+    "tsup": "^8.5.0",
+    "jsdom": "^28.0.0"
+  },
+  "devDependencies": {},
+  "bugs": {
+    "url": "https://github.com/SerhiiMaksymiv/targetprocess-mcp-server/issues"
+  },
+  "homepage": "https://github.com/SerhiiMaksymiv/targetprocess-mcp-server#readme"
+}