@radholm/azure-devops-mcp 1.0.0-beta.1

package/dist/tools/work.js

@@ -0,0 +1,391 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+import { z } from "zod";
+import { TreeStructureGroup, TreeNodeStructureType } from "azure-devops-node-api/interfaces/WorkItemTrackingInterfaces.js";
+import { elicitProject, elicitTeam } from "../shared/elicitations.js";
+const WORK_TOOLS = {
+    list_team_iterations: "work_list_team_iterations",
+    list_iterations: "work_list_iterations",
+    create_iterations: "work_create_iterations",
+    assign_iterations: "work_assign_iterations",
+    get_team_capacity: "work_get_team_capacity",
+    update_team_capacity: "work_update_team_capacity",
+    get_iteration_capacities: "work_get_iteration_capacities",
+    get_team_settings: "work_get_team_settings",
+};
+function configureWorkTools(server, _, connectionProvider) {
+    server.tool(WORK_TOOLS.list_team_iterations, "Retrieve a list of iterations for a specific team in a project. If a project or team is not specified, you will be prompted to select one.", {
+        project: z.string().optional().describe("The name or ID of the Azure DevOps project. Reuse from prior context if already known. If not provided, a project selection prompt will be shown."),
+        team: z.string().optional().describe("The name or ID of the Azure DevOps team. Reuse from prior context if already known. If not provided, a team selection prompt will be shown."),
+        timeframe: z.enum(["current"]).optional().describe("The timeframe for which to retrieve iterations. Currently, only 'current' is supported."),
+    }, async ({ project, team, timeframe }) => {
+        try {
+            const connection = await connectionProvider();
+            let resolvedProject = project;
+            if (!resolvedProject) {
+                const result = await elicitProject(server, connection, "Select the Azure DevOps project to list team iterations for.");
+                if ("response" in result)
+                    return result.response;
+                resolvedProject = result.resolved;
+            }
+            let resolvedTeam = team;
+            if (!resolvedTeam) {
+                const result = await elicitTeam(server, connection, resolvedProject, "Select the Azure DevOps team to list iterations for.");
+                if ("response" in result)
+                    return result.response;
+                resolvedTeam = result.resolved;
+            }
+            const workApi = await connection.getWorkApi();
+            const iterations = await workApi.getTeamIterations({ project: resolvedProject, team: resolvedTeam }, timeframe);
+            if (!iterations) {
+                return { content: [{ type: "text", text: "No iterations found" }], isError: true };
+            }
+            return {
+                content: [
+                    { type: "text", text: `Project: ${resolvedProject}, Team: ${resolvedTeam}` },
+                    { type: "text", text: JSON.stringify(iterations, null, 2) },
+                ],
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
+            return {
+                content: [{ type: "text", text: `Error fetching team iterations: ${errorMessage}` }],
+                isError: true,
+            };
+        }
+    });
+    server.tool(WORK_TOOLS.create_iterations, "Create new iterations in a specified Azure DevOps project.", {
+        project: z.string().describe("The name or ID of the Azure DevOps project."),
+        iterations: z
+            .array(z.object({
+            iterationName: z.string().describe("The name of the iteration to create."),
+            startDate: z.string().optional().describe("The start date of the iteration in ISO format (e.g., '2023-01-01T00:00:00Z'). Optional."),
+            finishDate: z.string().optional().describe("The finish date of the iteration in ISO format (e.g., '2023-01-31T23:59:59Z'). Optional."),
+        }))
+            .describe("An array of iterations to create. Each iteration must have a name and can optionally have start and finish dates in ISO format."),
+    }, async ({ project, iterations }) => {
+        try {
+            const connection = await connectionProvider();
+            const workItemTrackingApi = await connection.getWorkItemTrackingApi();
+            const results = [];
+            for (const { iterationName, startDate, finishDate } of iterations) {
+                // Step 1: Create the iteration
+                const iteration = await workItemTrackingApi.createOrUpdateClassificationNode({
+                    name: iterationName,
+                    attributes: {
+                        startDate: startDate ? new Date(startDate) : undefined,
+                        finishDate: finishDate ? new Date(finishDate) : undefined,
+                    },
+                }, project, TreeStructureGroup.Iterations);
+                if (iteration) {
+                    results.push(iteration);
+                }
+            }
+            if (results.length === 0) {
+                return { content: [{ type: "text", text: "No iterations were created" }], isError: true };
+            }
+            return {
+                content: [{ type: "text", text: JSON.stringify(results, null, 2) }],
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
+            return {
+                content: [{ type: "text", text: `Error creating iterations: ${errorMessage}` }],
+                isError: true,
+            };
+        }
+    });
+    server.tool(WORK_TOOLS.list_iterations, "List all iterations in a specified Azure DevOps project. If a project is not specified, you will be prompted to select one.", {
+        project: z.string().optional().describe("The name or ID of the Azure DevOps project. Reuse from prior context if already known. If not provided, a project selection prompt will be shown."),
+        depth: z.coerce.number().default(2).describe("Depth of children to fetch."),
+        excludedIds: z.array(z.coerce.number().min(1)).optional().describe("An optional array of iteration IDs, and thier children, that should not be returned."),
+    }, async ({ project, depth, excludedIds: ids }) => {
+        try {
+            const connection = await connectionProvider();
+            let resolvedProject = project;
+            if (!resolvedProject) {
+                const result = await elicitProject(server, connection, "Select the Azure DevOps project to list iterations for.");
+                if ("response" in result)
+                    return result.response;
+                resolvedProject = result.resolved;
+            }
+            const workItemTrackingApi = await connection.getWorkItemTrackingApi();
+            let results = [];
+            if (depth === undefined) {
+                depth = 1;
+            }
+            results = await workItemTrackingApi.getClassificationNodes(resolvedProject, [], depth);
+            // Handle null or undefined results
+            if (!results) {
+                return { content: [{ type: "text", text: "No iterations were found" }], isError: true };
+            }
+            // Filter out items with structureType=0 (Area nodes), only keep structureType=1 (Iteration nodes)
+            let filteredResults = results.filter((node) => node.structureType === TreeNodeStructureType.Iteration);
+            // If specific IDs are provided, filter them out recursively (exclude matching nodes and their children)
+            if (ids && ids.length > 0) {
+                const filterOutIds = (nodes) => {
+                    return nodes
+                        .filter((node) => !node.id || !ids.includes(node.id))
+                        .map((node) => {
+                        if (node.children && node.children.length > 0) {
+                            return {
+                                ...node,
+                                children: filterOutIds(node.children),
+                            };
+                        }
+                        return node;
+                    });
+                };
+                filteredResults = filterOutIds(filteredResults);
+            }
+            if (filteredResults.length === 0) {
+                return { content: [{ type: "text", text: "No iterations were found" }], isError: true };
+            }
+            return {
+                content: [{ type: "text", text: JSON.stringify(filteredResults, null, 2) }],
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
+            return {
+                content: [{ type: "text", text: `Error fetching iterations: ${errorMessage}` }],
+                isError: true,
+            };
+        }
+    });
+    server.tool(WORK_TOOLS.assign_iterations, "Assign existing iterations to a specific team in a project.", {
+        project: z.string().describe("The name or ID of the Azure DevOps project."),
+        team: z.string().describe("The name or ID of the Azure DevOps team."),
+        iterations: z
+            .array(z.object({
+            identifier: z.string().describe("The identifier of the iteration to assign."),
+            path: z.string().describe("The path of the iteration to assign, e.g., 'Project/Iteration'."),
+        }))
+            .describe("An array of iterations to assign. Each iteration must have an identifier and a path."),
+    }, async ({ project, team, iterations }) => {
+        try {
+            const connection = await connectionProvider();
+            const workApi = await connection.getWorkApi();
+            const teamContext = { project, team };
+            const results = [];
+            for (const { identifier, path } of iterations) {
+                const assignment = await workApi.postTeamIteration({ path: path, id: identifier }, teamContext);
+                if (assignment) {
+                    results.push(assignment);
+                }
+            }
+            if (results.length === 0) {
+                return { content: [{ type: "text", text: "No iterations were assigned to the team" }], isError: true };
+            }
+            return {
+                content: [{ type: "text", text: JSON.stringify(results, null, 2) }],
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
+            return {
+                content: [{ type: "text", text: `Error assigning iterations: ${errorMessage}` }],
+                isError: true,
+            };
+        }
+    });
+    server.tool(WORK_TOOLS.get_team_capacity, "Get the team capacity of a specific team and iteration in a project. If a project is not specified, you will be prompted to select one.", {
+        project: z.string().optional().describe("The name or Id of the Azure DevOps project. Reuse from prior context if already known. If not provided, a project selection prompt will be shown."),
+        team: z.string().describe("The name or Id of the Azure DevOps team. Reuse from prior context if already known."),
+        iterationId: z.string().describe("The Iteration Id to get capacity for."),
+    }, async ({ project, team, iterationId }) => {
+        try {
+            const connection = await connectionProvider();
+            let resolvedProject = project;
+            if (!resolvedProject) {
+                const result = await elicitProject(server, connection, "Select the Azure DevOps project to get team capacity for.");
+                if ("response" in result)
+                    return result.response;
+                resolvedProject = result.resolved;
+            }
+            const workApi = await connection.getWorkApi();
+            const teamContext = { project: resolvedProject, team };
+            const rawResults = await workApi.getCapacitiesWithIdentityRefAndTotals(teamContext, iterationId);
+            if (!rawResults || rawResults.teamMembers?.length === 0) {
+                return { content: [{ type: "text", text: "No team capacity assigned to the team" }], isError: true };
+            }
+            // Remove unwanted fields from teamMember and url
+            const simplifiedResults = {
+                ...rawResults,
+                teamMembers: (rawResults.teamMembers || []).map((member) => {
+                    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+                    const { url, ...rest } = member;
+                    return {
+                        ...rest,
+                        teamMember: member.teamMember
+                            ? {
+                                displayName: member.teamMember.displayName,
+                                id: member.teamMember.id,
+                                uniqueName: member.teamMember.uniqueName,
+                            }
+                            : undefined,
+                    };
+                }),
+            };
+            return {
+                content: [{ type: "text", text: JSON.stringify(simplifiedResults, null, 2) }],
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
+            return {
+                content: [{ type: "text", text: `Error getting team capacity: ${errorMessage}` }],
+                isError: true,
+            };
+        }
+    });
+    server.tool(WORK_TOOLS.update_team_capacity, "Update the team capacity of a team member for a specific iteration in a project.", {
+        project: z.string().describe("The name or Id of the Azure DevOps project."),
+        team: z.string().describe("The name or Id of the Azure DevOps team."),
+        teamMemberId: z.string().describe("The team member Id for the specific team member."),
+        iterationId: z.string().describe("The Iteration Id to update the capacity for."),
+        activities: z
+            .array(z.object({
+            name: z.string().describe("The name of the activity (e.g., 'Development')."),
+            capacityPerDay: z.number().describe("The capacity per day for this activity."),
+        }))
+            .describe("Array of activities and their daily capacities for the team member."),
+        daysOff: z
+            .array(z.object({
+            start: z.string().describe("Start date of the day off in ISO format."),
+            end: z.string().describe("End date of the day off in ISO format."),
+        }))
+            .optional()
+            .describe("Array of days off for the team member, each with a start and end date in ISO format."),
+    }, async ({ project, team, teamMemberId, iterationId, activities, daysOff }) => {
+        try {
+            const connection = await connectionProvider();
+            const workApi = await connection.getWorkApi();
+            const teamContext = { project, team };
+            // Prepare the capacity update object
+            const capacityPatch = {
+                activities: activities.map((a) => ({
+                    name: a.name,
+                    capacityPerDay: a.capacityPerDay,
+                })),
+                daysOff: (daysOff || []).map((d) => ({
+                    start: new Date(d.start),
+                    end: new Date(d.end),
+                })),
+            };
+            // Update the team member's capacity
+            const updatedCapacity = await workApi.updateCapacityWithIdentityRef(capacityPatch, teamContext, iterationId, teamMemberId);
+            if (!updatedCapacity) {
+                return { content: [{ type: "text", text: "Failed to update team member capacity" }], isError: true };
+            }
+            // Simplify output
+            const simplifiedResult = {
+                teamMember: updatedCapacity.teamMember
+                    ? {
+                        displayName: updatedCapacity.teamMember.displayName,
+                        id: updatedCapacity.teamMember.id,
+                        uniqueName: updatedCapacity.teamMember.uniqueName,
+                    }
+                    : undefined,
+                activities: updatedCapacity.activities,
+                daysOff: updatedCapacity.daysOff,
+            };
+            return {
+                content: [{ type: "text", text: JSON.stringify(simplifiedResult, null, 2) }],
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
+            return {
+                content: [{ type: "text", text: `Error updating team capacity: ${errorMessage}` }],
+                isError: true,
+            };
+        }
+    });
+    server.tool(WORK_TOOLS.get_iteration_capacities, "Get an iteration's capacity for all teams in iteration and project. If a project is not specified, you will be prompted to select one.", {
+        project: z.string().optional().describe("The name or Id of the Azure DevOps project. Reuse from prior context if already known. If not provided, a project selection prompt will be shown."),
+        iterationId: z.string().describe("The Iteration Id to get capacity for."),
+    }, async ({ project, iterationId }) => {
+        try {
+            const connection = await connectionProvider();
+            let resolvedProject = project;
+            if (!resolvedProject) {
+                const result = await elicitProject(server, connection, "Select the Azure DevOps project to get iteration capacities for.");
+                if ("response" in result)
+                    return result.response;
+                resolvedProject = result.resolved;
+            }
+            const workApi = await connection.getWorkApi();
+            const rawResults = await workApi.getTotalIterationCapacities(resolvedProject, iterationId);
+            if (!rawResults || !rawResults.teams || rawResults.teams.length === 0) {
+                return { content: [{ type: "text", text: "No iteration capacity assigned to the teams" }], isError: true };
+            }
+            return {
+                content: [{ type: "text", text: JSON.stringify(rawResults, null, 2) }],
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
+            return {
+                content: [{ type: "text", text: `Error getting iteration capacities: ${errorMessage}` }],
+                isError: true,
+            };
+        }
+    });
+    server.tool(WORK_TOOLS.get_team_settings, "Get team settings including default iteration, backlog iteration, and default area path for a team. If a project or team is not specified, you will be prompted to select one.", {
+        project: z.string().optional().describe("The name or ID of the Azure DevOps project. Reuse from prior context if already known. If not provided, a project selection prompt will be shown."),
+        team: z.string().optional().describe("The name or ID of the Azure DevOps team. Reuse from prior context if already known. If not provided, a team selection prompt will be shown."),
+    }, async ({ project, team }) => {
+        try {
+            const connection = await connectionProvider();
+            let resolvedProject = project;
+            if (!resolvedProject) {
+                const result = await elicitProject(server, connection, "Select the Azure DevOps project to get team settings for.");
+                if ("response" in result)
+                    return result.response;
+                resolvedProject = result.resolved;
+            }
+            let resolvedTeam = team;
+            if (!resolvedTeam) {
+                const result = await elicitTeam(server, connection, resolvedProject, "Select the Azure DevOps team to get settings for.");
+                if ("response" in result)
+                    return result.response;
+                resolvedTeam = result.resolved;
+            }
+            const workApi = await connection.getWorkApi();
+            const teamContext = { project: resolvedProject, team: resolvedTeam };
+            const teamSettings = await workApi.getTeamSettings(teamContext);
+            if (!teamSettings) {
+                return { content: [{ type: "text", text: "No team settings found" }], isError: true };
+            }
+            const teamFieldValues = await workApi.getTeamFieldValues(teamContext);
+            const result = {
+                backlogIteration: teamSettings.backlogIteration,
+                defaultIteration: teamSettings.defaultIteration,
+                defaultIterationMacro: teamSettings.defaultIterationMacro,
+                backlogVisibilities: teamSettings.backlogVisibilities,
+                bugsBehavior: teamSettings.bugsBehavior,
+                workingDays: teamSettings.workingDays,
+                defaultAreaPath: teamFieldValues?.defaultValue,
+                areaPathField: teamFieldValues?.field,
+                areaPaths: teamFieldValues?.values,
+            };
+            return {
+                content: [
+                    { type: "text", text: `Project: ${resolvedProject}, Team: ${resolvedTeam}` },
+                    { type: "text", text: JSON.stringify(result, null, 2) },
+                ],
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
+            return {
+                content: [{ type: "text", text: `Error fetching team settings: ${errorMessage}` }],
+                isError: true,
+            };
+        }
+    });
+}
+export { WORK_TOOLS, configureWorkTools };

package/dist/tools.js

@@ -0,0 +1,31 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+import { Domain } from "./shared/domains.js";
+import { configureAdvSecTools } from "./tools/advanced-security.js";
+import { configureMcpAppsTools } from "./tools/mcp-apps.js";
+import { configurePipelineTools } from "./tools/pipelines.js";
+import { configureCoreTools } from "./tools/core.js";
+import { configureRepoTools } from "./tools/repositories.js";
+import { configureSearchTools } from "./tools/search.js";
+import { configureTestPlanTools } from "./tools/test-plans.js";
+import { configureWikiTools } from "./tools/wiki.js";
+import { configureWorkTools } from "./tools/work.js";
+import { configureWorkItemTools } from "./tools/work-items.js";
+function configureAllTools(server, tokenProvider, connectionProvider, userAgentProvider, enabledDomains) {
+    const configureIfDomainEnabled = (domain, configureFn) => {
+        if (enabledDomains.has(domain)) {
+            configureFn();
+        }
+    };
+    configureIfDomainEnabled(Domain.CORE, () => configureCoreTools(server, tokenProvider, connectionProvider, userAgentProvider));
+    configureIfDomainEnabled(Domain.MCP_APPS, () => configureMcpAppsTools(server));
+    configureIfDomainEnabled(Domain.WORK, () => configureWorkTools(server, tokenProvider, connectionProvider));
+    configureIfDomainEnabled(Domain.PIPELINES, () => configurePipelineTools(server, tokenProvider, connectionProvider, userAgentProvider));
+    configureIfDomainEnabled(Domain.REPOSITORIES, () => configureRepoTools(server, tokenProvider, connectionProvider, userAgentProvider));
+    configureIfDomainEnabled(Domain.WORK_ITEMS, () => configureWorkItemTools(server, tokenProvider, connectionProvider, userAgentProvider));
+    configureIfDomainEnabled(Domain.WIKI, () => configureWikiTools(server, tokenProvider, connectionProvider, userAgentProvider));
+    configureIfDomainEnabled(Domain.TEST_PLANS, () => configureTestPlanTools(server, tokenProvider, connectionProvider, userAgentProvider));
+    configureIfDomainEnabled(Domain.SEARCH, () => configureSearchTools(server, tokenProvider, connectionProvider, userAgentProvider));
+    configureIfDomainEnabled(Domain.ADVANCED_SECURITY, () => configureAdvSecTools(server, tokenProvider, connectionProvider));
+}
+export { configureAllTools };

package/dist/useragent.js

@@ -0,0 +1,20 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+class UserAgentComposer {
+    _userAgent;
+    _mcpClientInfoAppended;
+    constructor(packageVersion) {
+        this._userAgent = `AzureDevOps.MCP/${packageVersion} (local)`;
+        this._mcpClientInfoAppended = false;
+    }
+    get userAgent() {
+        return this._userAgent;
+    }
+    appendMcpClientInfo(info) {
+        if (!this._mcpClientInfoAppended && info && info.name && info.version) {
+            this._userAgent += ` ${info.name}/${info.version}`;
+            this._mcpClientInfoAppended = true;
+        }
+    }
+}
+export { UserAgentComposer };

package/dist/utils.js

@@ -0,0 +1,118 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+/**
+ * Default API versions for Azure DevOps cloud.
+ * On-premises Azure DevOps Server may not support these versions.
+ * Users can override via the AZURE_DEVOPS_API_VERSION environment variable.
+ *
+ * Supported on-prem versions:
+ *   - Azure DevOps Server 2022: up to 7.1
+ *   - Azure DevOps Server 2020: up to 6.0
+ *   - Azure DevOps Server 2019: up to 5.1
+ */
+const defaultApiVersion = "7.2-preview.1";
+export const apiVersion = process.env.AZURE_DEVOPS_API_VERSION ?? defaultApiVersion;
+export const batchApiVersion = "5.0";
+export const markdownCommentsApiVersion = process.env.AZURE_DEVOPS_API_VERSION ?? "7.2-preview.4";
+export function createEnumMapping(enumObject) {
+    const mapping = {};
+    for (const [key, value] of Object.entries(enumObject)) {
+        if (typeof key === "string" && typeof value === "number") {
+            mapping[key.toLowerCase()] = value;
+        }
+    }
+    return mapping;
+}
+export function mapStringToEnum(value, enumObject, defaultValue) {
+    if (!value)
+        return defaultValue;
+    const enumMapping = createEnumMapping(enumObject);
+    return enumMapping[value.toLowerCase()] ?? defaultValue;
+}
+/**
+ * Maps an array of strings to an array of enum values, filtering out invalid values.
+ * @param values Array of string values to map
+ * @param enumObject The enum object to map to
+ * @returns Array of valid enum values
+ */
+export function mapStringArrayToEnum(values, enumObject) {
+    if (!values)
+        return [];
+    return values.map((value) => mapStringToEnum(value, enumObject)).filter((v) => v !== undefined);
+}
+/**
+ * Converts a TypeScript numeric enum to an array of string keys for use with z.enum().
+ * This ensures that enum schemas generate string values rather than numeric values.
+ * @param enumObject The TypeScript enum object
+ * @returns Array of string keys from the enum
+ */
+export function getEnumKeys(enumObject) {
+    return Object.keys(enumObject).filter((key) => isNaN(Number(key)));
+}
+/**
+ * Safely converts a string enum key to its corresponding enum value.
+ * Validates that the key exists in the enum before conversion.
+ * @param enumObject The TypeScript enum object
+ * @param key The string key to convert
+ * @returns The enum value if key is valid, undefined otherwise
+ */
+export function safeEnumConvert(enumObject, key) {
+    if (!key)
+        return undefined;
+    const validKeys = getEnumKeys(enumObject);
+    if (!validKeys.includes(key)) {
+        return undefined;
+    }
+    return enumObject[key];
+}
+/**
+ * Encodes `>` and `<` for Markdown formatted fields.
+ *
+ * @param value The text value to encode
+ * @param format The format of the field ('Markdown' or 'Html')
+ * @returns The encoded text, or original text if format is not Markdown
+ */
+export function encodeFormattedValue(value, format) {
+    if (!value || format !== "Markdown")
+        return value;
+    const result = value.replace(/</g, "&lt;").replace(/>/g, "&gt;");
+    return result;
+}
+/**
+ * Detects whether a string returned from an ADO API stream is actually an error
+ * response serialized as JSON (e.g. a 404 GitItemNotFoundException or
+ * WikiPageNotFoundException) rather than real content.
+ *
+ * The ADO Node API client swallows non-2xx HTTP responses and delivers the
+ * error body as a stream, so callers must check explicitly after reading.
+ *
+ * @returns The human-readable error message extracted from the JSON, or null if
+ *          the content is not an ADO error response.
+ */
+export function extractAdoStreamError(content) {
+    try {
+        const json = JSON.parse(content.trim());
+        if (json && typeof json.typeName === "string" && typeof json.message === "string") {
+            return json.message;
+        }
+    }
+    catch {
+        // Not JSON — not an ADO error response.
+    }
+    return null;
+}
+/**
+ * Convert a Node.js ReadableStream to a string.
+ * Shared utility for consistent stream handling across tools.
+ */
+export function streamToString(stream) {
+    return new Promise((resolve, reject) => {
+        let data = "";
+        stream.setEncoding("utf8");
+        stream.on("data", (chunk) => {
+            data += chunk;
+        });
+        stream.on("error", reject);
+        stream.on("end", () => resolve(data));
+    });
+}

package/dist/version.js

@@ -0,0 +1 @@
+export const packageVersion = "1.0.0-beta.1";

package/package.json

@@ -0,0 +1,73 @@
+{
+  "name": "@radholm/azure-devops-mcp",
+  "version": "1.0.0-beta.1",
+  "description": "MCP server for interacting with Azure DevOps",
+  "license": "MIT",
+  "author": "Fredrik Radholm",
+  "homepage": "https://github.com/radholm/azure-devops-mcp",
+  "bugs": "https://github.com/radholm/azure-devops-mcp/issues",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/radholm/azure-devops-mcp.git"
+  },
+  "type": "module",
+  "bin": {
+    "mcp-server-azuredevops": "dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "preinstall": "npm config set registry https://registry.npmjs.org/",
+    "prebuild": "node -p \"'export const packageVersion = ' + JSON.stringify(require('./package.json').version) + ';\\n'\" > src/version.ts && prettier --write src/version.ts",
+    "validate-tools": "tsc --noEmit && node scripts/build-validate-tools.js",
+    "build": "tsc && shx chmod +x dist/*.js",
+    "prepare": "npm run build && husky",
+    "watch": "tsc --watch",
+    "inspect": "ALLOWED_ORIGINS=http://127.0.0.1:6274 npx @modelcontextprotocol/inspector@0.21.0 node dist/index.js",
+    "start": "node -r tsconfig-paths/register dist/index.js",
+    "eslint": "eslint",
+    "eslint-fix": "eslint --fix",
+    "format": "prettier --write azure-devops-mcp",
+    "format-check": "prettier --check azure-devops-mcp",
+    "clean": "shx rm -rf dist",
+    "test": "jest"
+  },
+  "dependencies": {
+    "@azure/identity": "^4.10.0",
+    "@azure/msal-node": "^5.0.6",
+    "@modelcontextprotocol/sdk": "1.29.0",
+    "azure-devops-extension-api": "^4.264.0",
+    "azure-devops-extension-sdk": "^4.0.2",
+    "azure-devops-node-api": "^15.1.2",
+    "winston": "^3.18.3",
+    "yargs": "^18.0.0",
+    "zod": "^3.25.63",
+    "zod-to-json-schema": "^3.24.5"
+  },
+  "devDependencies": {
+    "@types/jest": "^30.0.0",
+    "@types/node": "^22.19.1",
+    "eslint-config-prettier": "10.1.8",
+    "eslint-plugin-header": "^3.1.1",
+    "glob": "^13.0.0",
+    "husky": "^9.1.7",
+    "jest": "^30.0.2",
+    "jest-extended": "^7.0.0",
+    "lint-staged": "^17.0.0",
+    "prettier": "3.8.3",
+    "shx": "^0.4.0",
+    "ts-jest": "^29.4.6",
+    "tsconfig-paths": "^4.2.0",
+    "typescript": "^5.9.3",
+    "typescript-eslint": "^8.54.0"
+  },
+  "lint-staged": {
+    "**/*.(js|ts|jsx|tsx|json|css|md)": [
+      "npm run format"
+    ]
+  }
+}