@azure-devops/mcp 1.2.0 → 1.3.0

package/dist/tools/repos.js

@@ -1,6 +1,6 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
-import { PullRequestStatus, GitVersionType, GitPullRequestQueryType, } from "azure-devops-node-api/interfaces/GitInterfaces.js";
+import { PullRequestStatus, GitVersionType, GitPullRequestQueryType, CommentThreadStatus, } from "azure-devops-node-api/interfaces/GitInterfaces.js";
 import { z } from "zod";
 import { getCurrentUserDetails } from "./auth.js";
 import { getEnumKeys } from "../utils.js";
@@ -16,9 +16,10 @@ const REPO_TOOLS = {
     get_branch_by_name: "repo_get_branch_by_name",
     get_pull_request_by_id: "repo_get_pull_request_by_id",
     create_pull_request: "repo_create_pull_request",
-    update_pull_request_status: "repo_update_pull_request_status",
+    update_pull_request: "repo_update_pull_request",
     update_pull_request_reviewers: "repo_update_pull_request_reviewers",
     reply_to_comment: "repo_reply_to_comment",
+    create_pull_request_thread: "repo_create_pull_request_thread",
     resolve_comment: "repo_resolve_comment",
     search_commits: "repo_search_commits",
     list_pull_requests_by_commits: "repo_list_pull_requests_by_commits",
@@ -31,6 +32,26 @@ function branchesFilterOutIrrelevantProperties(branches, top) {
         .sort((a, b) => b.localeCompare(a))
         .slice(0, top);
 }
+/**
+ * Trims comment data to essential properties, filtering out deleted comments
+ * @param comments Array of comments to trim (can be undefined/null)
+ * @returns Array of trimmed comment objects with essential properties only
+ */
+function trimComments(comments) {
+    return comments
+        ?.filter((comment) => !comment.isDeleted) // Exclude deleted comments
+        ?.map((comment) => ({
+        id: comment.id,
+        author: {
+            displayName: comment.author?.displayName,
+            uniqueName: comment.author?.uniqueName,
+        },
+        content: comment.content,
+        publishedDate: comment.publishedDate,
+        lastUpdatedDate: comment.lastUpdatedDate,
+        lastContentUpdatedDate: comment.lastContentUpdatedDate,
+    }));
+}
 function pullRequestStatusStringToInt(status) {
     switch (status) {
         case "Abandoned":
@@ -61,10 +82,18 @@ function configureRepoTools(server, tokenProvider, connectionProvider) {
         description: z.string().optional().describe("The description of the pull request. Optional."),
         isDraft: z.boolean().optional().default(false).describe("Indicates whether the pull request is a draft. Defaults to false."),
         workItems: z.string().optional().describe("Work item IDs to associate with the pull request, space-separated."),
-    }, async ({ repositoryId, sourceRefName, targetRefName, title, description, isDraft, workItems }) => {
+        forkSourceRepositoryId: z.string().optional().describe("The ID of the fork repository that the pull request originates from. Optional, used when creating a pull request from a fork."),
+    }, async ({ repositoryId, sourceRefName, targetRefName, title, description, isDraft, workItems, forkSourceRepositoryId }) => {
         const connection = await connectionProvider();
         const gitApi = await connection.getGitApi();
         const workItemRefs = workItems ? workItems.split(" ").map((id) => ({ id: id.trim() })) : [];
+        const forkSource = forkSourceRepositoryId
+            ? {
+                repository: {
+                    id: forkSourceRepositoryId,
+                },
+            }
+            : undefined;
         const pullRequest = await gitApi.createPullRequest({
             sourceRefName,
             targetRefName,
@@ -72,20 +101,44 @@ function configureRepoTools(server, tokenProvider, connectionProvider) {
             description,
             isDraft,
             workItemRefs: workItemRefs,
+            forkSource,
         }, repositoryId);
         return {
             content: [{ type: "text", text: JSON.stringify(pullRequest, null, 2) }],
         };
     });
-    server.tool(REPO_TOOLS.update_pull_request_status, "Update status of an existing pull request to active or abandoned.", {
+    server.tool(REPO_TOOLS.update_pull_request, "Update a Pull Request by ID with specified fields.", {
         repositoryId: z.string().describe("The ID of the repository where the pull request exists."),
-        pullRequestId: z.number().describe("The ID of the pull request to be published."),
-        status: z.enum(["Active", "Abandoned"]).describe("The new status of the pull request. Can be 'Active' or 'Abandoned'."),
-    }, async ({ repositoryId, pullRequestId, status }) => {
+        pullRequestId: z.number().describe("The ID of the pull request to update."),
+        title: z.string().optional().describe("The new title for the pull request."),
+        description: z.string().optional().describe("The new description for the pull request."),
+        isDraft: z.boolean().optional().describe("Whether the pull request should be a draft."),
+        targetRefName: z.string().optional().describe("The new target branch name (e.g., 'refs/heads/main')."),
+        status: z.enum(["Active", "Abandoned"]).optional().describe("The new status of the pull request. Can be 'Active' or 'Abandoned'."),
+    }, async ({ repositoryId, pullRequestId, title, description, isDraft, targetRefName, status }) => {
         const connection = await connectionProvider();
         const gitApi = await connection.getGitApi();
-        const statusValue = status === "Active" ? PullRequestStatus.Active.valueOf() : PullRequestStatus.Abandoned.valueOf();
-        const updatedPullRequest = await gitApi.updatePullRequest({ status: statusValue }, repositoryId, pullRequestId);
+        // Build update object with only provided fields
+        const updateRequest = {};
+        if (title !== undefined)
+            updateRequest.title = title;
+        if (description !== undefined)
+            updateRequest.description = description;
+        if (isDraft !== undefined)
+            updateRequest.isDraft = isDraft;
+        if (targetRefName !== undefined)
+            updateRequest.targetRefName = targetRefName;
+        if (status !== undefined) {
+            updateRequest.status = status === "Active" ? PullRequestStatus.Active.valueOf() : PullRequestStatus.Abandoned.valueOf();
+        }
+        // Validate that at least one field is provided for update
+        if (Object.keys(updateRequest).length === 0) {
+            return {
+                content: [{ type: "text", text: "Error: At least one field (title, description, isDraft, targetRefName, or status) must be provided for update." }],
+                isError: true,
+            };
+        }
+        const updatedPullRequest = await gitApi.updatePullRequest(updateRequest, repositoryId, pullRequestId);
         return {
             content: [{ type: "text", text: JSON.stringify(updatedPullRequest, null, 2) }],
         };
@@ -242,13 +295,27 @@ function configureRepoTools(server, tokenProvider, connectionProvider) {
         baseIteration: z.number().optional().describe("The base iteration ID for which to retrieve threads. Optional, defaults to the latest base iteration."),
         top: z.number().default(100).describe("The maximum number of threads to return."),
         skip: z.number().default(0).describe("The number of threads to skip."),
-    }, async ({ repositoryId, pullRequestId, project, iteration, baseIteration, top, skip }) => {
+        fullResponse: z.boolean().optional().default(false).describe("Return full thread JSON response instead of trimmed data."),
+    }, async ({ repositoryId, pullRequestId, project, iteration, baseIteration, top, skip, fullResponse }) => {
         const connection = await connectionProvider();
         const gitApi = await connection.getGitApi();
         const threads = await gitApi.getThreads(repositoryId, pullRequestId, project, iteration, baseIteration);
         const paginatedThreads = threads?.sort((a, b) => (a.id ?? 0) - (b.id ?? 0)).slice(skip, skip + top);
+        if (fullResponse) {
+            return {
+                content: [{ type: "text", text: JSON.stringify(paginatedThreads, null, 2) }],
+            };
+        }
+        // Return trimmed thread data focusing on essential information
+        const trimmedThreads = paginatedThreads?.map((thread) => ({
+            id: thread.id,
+            publishedDate: thread.publishedDate,
+            lastUpdatedDate: thread.lastUpdatedDate,
+            status: thread.status,
+            comments: trimComments(thread.comments),
+        }));
         return {
-            content: [{ type: "text", text: JSON.stringify(paginatedThreads, null, 2) }],
+            content: [{ type: "text", text: JSON.stringify(trimmedThreads, null, 2) }],
         };
     });
     server.tool(REPO_TOOLS.list_pull_request_thread_comments, "Retrieve a list of comments in a pull request thread.", {
@@ -258,14 +325,22 @@ function configureRepoTools(server, tokenProvider, connectionProvider) {
         project: z.string().optional().describe("Project ID or project name (optional)"),
         top: z.number().default(100).describe("The maximum number of comments to return."),
         skip: z.number().default(0).describe("The number of comments to skip."),
-    }, async ({ repositoryId, pullRequestId, threadId, project, top, skip }) => {
+        fullResponse: z.boolean().optional().default(false).describe("Return full comment JSON response instead of trimmed data."),
+    }, async ({ repositoryId, pullRequestId, threadId, project, top, skip, fullResponse }) => {
         const connection = await connectionProvider();
         const gitApi = await connection.getGitApi();
         // Get thread comments - GitApi uses getComments for retrieving comments from a specific thread
         const comments = await gitApi.getComments(repositoryId, pullRequestId, threadId, project);
         const paginatedComments = comments?.sort((a, b) => (a.id ?? 0) - (b.id ?? 0)).slice(skip, skip + top);
+        if (fullResponse) {
+            return {
+                content: [{ type: "text", text: JSON.stringify(paginatedComments, null, 2) }],
+            };
+        }
+        // Return trimmed comment data focusing on essential information
+        const trimmedComments = trimComments(paginatedComments);
         return {
-            content: [{ type: "text", text: JSON.stringify(paginatedComments, null, 2) }],
+            content: [{ type: "text", text: JSON.stringify(trimmedComments, null, 2) }],
         };
     });
     server.tool(REPO_TOOLS.list_branches_by_repo, "Retrieve a list of branches for a given repository.", {
@@ -332,10 +407,11 @@ function configureRepoTools(server, tokenProvider, connectionProvider) {
     server.tool(REPO_TOOLS.get_pull_request_by_id, "Get a pull request by its ID.", {
         repositoryId: z.string().describe("The ID of the repository where the pull request is located."),
         pullRequestId: z.number().describe("The ID of the pull request to retrieve."),
-    }, async ({ repositoryId, pullRequestId }) => {
+        includeWorkItemRefs: z.boolean().optional().default(false).describe("Whether to reference work items associated with the pull request."),
+    }, async ({ repositoryId, pullRequestId, includeWorkItemRefs }) => {
         const connection = await connectionProvider();
         const gitApi = await connection.getGitApi();
-        const pullRequest = await gitApi.getPullRequest(repositoryId, pullRequestId);
+        const pullRequest = await gitApi.getPullRequest(repositoryId, pullRequestId, undefined, undefined, undefined, undefined, undefined, includeWorkItemRefs);
         return {
             content: [{ type: "text", text: JSON.stringify(pullRequest, null, 2) }],
         };
@@ -346,25 +422,111 @@ function configureRepoTools(server, tokenProvider, connectionProvider) {
         threadId: z.number().describe("The ID of the thread to which the comment will be added."),
         content: z.string().describe("The content of the comment to be added."),
         project: z.string().optional().describe("Project ID or project name (optional)"),
-    }, async ({ repositoryId, pullRequestId, threadId, content, project }) => {
+        fullResponse: z.boolean().optional().default(false).describe("Return full comment JSON response instead of a simple confirmation message."),
+    }, async ({ repositoryId, pullRequestId, threadId, content, project, fullResponse }) => {
         const connection = await connectionProvider();
         const gitApi = await connection.getGitApi();
         const comment = await gitApi.createComment({ content }, repositoryId, pullRequestId, threadId, project);
+        // Check if the comment was successfully created
+        if (!comment) {
+            return {
+                content: [{ type: "text", text: `Error: Failed to add comment to thread ${threadId}. The comment was not created successfully.` }],
+                isError: true,
+            };
+        }
+        if (fullResponse) {
+            return {
+                content: [{ type: "text", text: JSON.stringify(comment, null, 2) }],
+            };
+        }
+        return {
+            content: [{ type: "text", text: `Comment successfully added to thread ${threadId}.` }],
+        };
+    });
+    server.tool(REPO_TOOLS.create_pull_request_thread, "Creates a new comment thread on a pull request.", {
+        repositoryId: z.string().describe("The ID of the repository where the pull request is located."),
+        pullRequestId: z.number().describe("The ID of the pull request where the comment thread exists."),
+        content: z.string().describe("The content of the comment to be added."),
+        project: z.string().optional().describe("Project ID or project name (optional)"),
+        filePath: z.string().optional().describe("The path of the file where the comment thread will be created. (optional)"),
+        status: z
+            .enum(getEnumKeys(CommentThreadStatus))
+            .optional()
+            .default(CommentThreadStatus[CommentThreadStatus.Active])
+            .describe("The status of the comment thread. Defaults to 'Active'."),
+        rightFileStartLine: z.number().optional().describe("Position of first character of the thread's span in right file. The line number of a thread's position. Starts at 1. (optional)"),
+        rightFileStartOffset: z
+            .number()
+            .optional()
+            .describe("Position of first character of the thread's span in right file. The line number of a thread's position. The character offset of a thread's position inside of a line. Starts at 1. Must only be set if rightFileStartLine is also specified. (optional)"),
+        rightFileEndLine: z
+            .number()
+            .optional()
+            .describe("Position of last character of the thread's span in right file. The line number of a thread's position. Starts at 1. Must only be set if rightFileStartLine is also specified. (optional)"),
+        rightFileEndOffset: z
+            .number()
+            .optional()
+            .describe("Position of last character of the thread's span in right file. The character offset of a thread's position inside of a line. Must only be set if rightFileEndLine is also specified. (optional)"),
+    }, async ({ repositoryId, pullRequestId, content, project, filePath, status, rightFileStartLine, rightFileStartOffset, rightFileEndLine, rightFileEndOffset }) => {
+        const connection = await connectionProvider();
+        const gitApi = await connection.getGitApi();
+        const threadContext = { filePath: filePath };
+        if (rightFileStartLine !== undefined) {
+            if (rightFileStartLine < 1) {
+                throw new Error("rightFileStartLine must be greater than or equal to 1.");
+            }
+            threadContext.rightFileStart = { line: rightFileStartLine };
+            if (rightFileStartOffset !== undefined) {
+                if (rightFileStartOffset < 1) {
+                    throw new Error("rightFileStartOffset must be greater than or equal to 1.");
+                }
+                threadContext.rightFileStart.offset = rightFileStartOffset;
+            }
+        }
+        if (rightFileEndLine !== undefined) {
+            if (rightFileStartLine === undefined) {
+                throw new Error("rightFileEndLine must only be specified if rightFileStartLine is also specified.");
+            }
+            if (rightFileEndLine < 1) {
+                throw new Error("rightFileEndLine must be greater than or equal to 1.");
+            }
+            threadContext.rightFileEnd = { line: rightFileEndLine };
+            if (rightFileEndOffset !== undefined) {
+                if (rightFileEndOffset < 1) {
+                    throw new Error("rightFileEndOffset must be greater than or equal to 1.");
+                }
+                threadContext.rightFileEnd.offset = rightFileEndOffset;
+            }
+        }
+        const thread = await gitApi.createThread({ comments: [{ content: content }], threadContext: threadContext, status: CommentThreadStatus[status] }, repositoryId, pullRequestId, project);
         return {
-            content: [{ type: "text", text: JSON.stringify(comment, null, 2) }],
+            content: [{ type: "text", text: JSON.stringify(thread, null, 2) }],
         };
     });
     server.tool(REPO_TOOLS.resolve_comment, "Resolves a specific comment thread on a pull request.", {
         repositoryId: z.string().describe("The ID of the repository where the pull request is located."),
         pullRequestId: z.number().describe("The ID of the pull request where the comment thread exists."),
         threadId: z.number().describe("The ID of the thread to be resolved."),
-    }, async ({ repositoryId, pullRequestId, threadId }) => {
+        fullResponse: z.boolean().optional().default(false).describe("Return full thread JSON response instead of a simple confirmation message."),
+    }, async ({ repositoryId, pullRequestId, threadId, fullResponse }) => {
         const connection = await connectionProvider();
         const gitApi = await connection.getGitApi();
         const thread = await gitApi.updateThread({ status: 2 }, // 2 corresponds to "Resolved" status
         repositoryId, pullRequestId, threadId);
+        // Check if the thread was successfully resolved
+        if (!thread) {
+            return {
+                content: [{ type: "text", text: `Error: Failed to resolve thread ${threadId}. The thread status was not updated successfully.` }],
+                isError: true,
+            };
+        }
+        if (fullResponse) {
+            return {
+                content: [{ type: "text", text: JSON.stringify(thread, null, 2) }],
+            };
+        }
         return {
-            content: [{ type: "text", text: JSON.stringify(thread, null, 2) }],
+            content: [{ type: "text", text: `Thread ${threadId} was successfully resolved.` }],
         };
     });
     const gitVersionTypeStrings = Object.values(GitVersionType).filter((value) => typeof value === "string");

package/dist/tools/search.js

@@ -17,17 +17,17 @@ function configureSearchTools(server, tokenProvider, connectionProvider, userAge
         path: z.array(z.string()).optional().describe("Filter by paths"),
         branch: z.array(z.string()).optional().describe("Filter by branches"),
         includeFacets: z.boolean().default(false).describe("Include facets in the search results"),
-        $skip: z.number().default(0).describe("Number of results to skip"),
-        $top: z.number().default(5).describe("Maximum number of results to return"),
-    }, async ({ searchText, project, repository, path, branch, includeFacets, $skip, $top }) => {
+        skip: z.number().default(0).describe("Number of results to skip"),
+        top: z.number().default(5).describe("Maximum number of results to return"),
+    }, async ({ searchText, project, repository, path, branch, includeFacets, skip, top }) => {
         const accessToken = await tokenProvider();
         const connection = await connectionProvider();
         const url = `https://almsearch.dev.azure.com/${orgName}/_apis/search/codesearchresults?api-version=${apiVersion}`;
         const requestBody = {
             searchText,
             includeFacets,
-            $skip,
-            $top,
+            $skip: skip,
+            $top: top,
         };
         const filters = {};
         if (project && project.length > 0)
@@ -66,16 +66,16 @@ function configureSearchTools(server, tokenProvider, connectionProvider, userAge
         project: z.array(z.string()).optional().describe("Filter by projects"),
         wiki: z.array(z.string()).optional().describe("Filter by wiki names"),
         includeFacets: z.boolean().default(false).describe("Include facets in the search results"),
-        $skip: z.number().default(0).describe("Number of results to skip"),
-        $top: z.number().default(10).describe("Maximum number of results to return"),
-    }, async ({ searchText, project, wiki, includeFacets, $skip, $top }) => {
+        skip: z.number().default(0).describe("Number of results to skip"),
+        top: z.number().default(10).describe("Maximum number of results to return"),
+    }, async ({ searchText, project, wiki, includeFacets, skip, top }) => {
         const accessToken = await tokenProvider();
         const url = `https://almsearch.dev.azure.com/${orgName}/_apis/search/wikisearchresults?api-version=${apiVersion}`;
         const requestBody = {
             searchText,
             includeFacets,
-            $skip,
-            $top,
+            $skip: skip,
+            $top: top,
         };
         const filters = {};
         if (project && project.length > 0)
@@ -110,16 +110,16 @@ function configureSearchTools(server, tokenProvider, connectionProvider, userAge
         state: z.array(z.string()).optional().describe("Filter by work item states"),
         assignedTo: z.array(z.string()).optional().describe("Filter by assigned to users"),
         includeFacets: z.boolean().default(false).describe("Include facets in the search results"),
-        $skip: z.number().default(0).describe("Number of results to skip for pagination"),
-        $top: z.number().default(10).describe("Number of results to return"),
-    }, async ({ searchText, project, areaPath, workItemType, state, assignedTo, includeFacets, $skip, $top }) => {
+        skip: z.number().default(0).describe("Number of results to skip for pagination"),
+        top: z.number().default(10).describe("Number of results to return"),
+    }, async ({ searchText, project, areaPath, workItemType, state, assignedTo, includeFacets, skip, top }) => {
         const accessToken = await tokenProvider();
         const url = `https://almsearch.dev.azure.com/${orgName}/_apis/search/workitemsearchresults?api-version=${apiVersion}`;
         const requestBody = {
             searchText,
             includeFacets,
-            $skip,
-            $top,
+            $skip: skip,
+            $top: top,
         };
         const filters = {};
         if (project && project.length > 0)

package/dist/tools/testplan.test.js

@@ -0,0 +1,125 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+import { describe, expect, it } from '@jest/globals';
+import { configureTestPlanTools } from '../../../src/tools/testplans';
+describe("configureTestPlanTools", () => {
+    let server;
+    let tokenProvider;
+    let connectionProvider;
+    let mockConnection;
+    let mockTestPlanApi;
+    let mockTestResultsApi;
+    beforeEach(() => {
+        server = { tool: jest.fn() };
+        tokenProvider = jest.fn();
+        mockTestPlanApi = {
+            getTestPlans: jest.fn(),
+            createTestPlan: jest.fn(),
+            addTestCasesToSuite: jest.fn(),
+            getTestCaseList: jest.fn(),
+        };
+        mockTestResultsApi = {
+            getTestResultDetailsForBuild: jest.fn(),
+        };
+        mockConnection = {
+            getTestPlanApi: jest.fn().mockResolvedValue(mockTestPlanApi),
+            getTestResultsApi: jest.fn().mockResolvedValue(mockTestResultsApi),
+        };
+        connectionProvider = jest.fn().mockResolvedValue(mockConnection);
+    });
+    describe("tool registration", () => {
+        it("registers test plan tools on the server", () => {
+            configureTestPlanTools(server, tokenProvider, connectionProvider);
+            expect(server.tool.mock.calls.map(call => call[0])).toEqual(expect.arrayContaining([
+                "ado_list_test_plans",
+                "ado_create_test_plan",
+                "ado_add_test_cases_to_suite",
+                "ado_list_test_cases",
+                "ado_show_test_results_from_build_id",
+            ]));
+        });
+    });
+    describe("list_test_plans tool", () => {
+        it("should call getTestPlans with the correct parameters and return the expected result", async () => {
+            configureTestPlanTools(server, tokenProvider, connectionProvider);
+            const call = server.tool.mock.calls.find(([toolName]) => toolName === "ado_list_test_plans");
+            if (!call)
+                throw new Error("ado_list_test_plans tool not registered");
+            const [, , , handler] = call;
+            mockTestPlanApi.getTestPlans.mockResolvedValue([{ id: 1, name: "Test Plan 1" }]);
+            const params = {
+                project: "proj1",
+                filterActivePlans: true,
+                includePlanDetails: false,
+                continuationToken: undefined,
+            };
+            const result = await handler(params);
+            expect(mockTestPlanApi.getTestPlans).toHaveBeenCalledWith("proj1", "", undefined, false, true);
+            expect(result.content[0].text).toBe(JSON.stringify([{ id: 1, name: "Test Plan 1" }], null, 2));
+        });
+    });
+    describe("create_test_plan tool", () => {
+        it("should call createTestPlan with the correct parameters and return the expected result", async () => {
+            configureTestPlanTools(server, tokenProvider, connectionProvider);
+            const call = server.tool.mock.calls.find(([toolName]) => toolName === "ado_create_test_plan");
+            if (!call)
+                throw new Error("ado_create_test_plan tool not registered");
+            const [, , , handler] = call;
+            mockTestPlanApi.createTestPlan.mockResolvedValue({ id: 1, name: "New Test Plan" });
+            const params = {
+                project: "proj1",
+                name: "New Test Plan",
+                iteration: "Iteration 1",
+                description: "Description",
+                startDate: "2025-05-01",
+                endDate: "2025-05-31",
+                areaPath: "Area 1",
+            };
+            const result = await handler(params);
+            expect(mockTestPlanApi.createTestPlan).toHaveBeenCalledWith({
+                name: "New Test Plan",
+                iteration: "Iteration 1",
+                description: "Description",
+                startDate: new Date("2025-05-01"),
+                endDate: new Date("2025-05-31"),
+                areaPath: "Area 1",
+            }, "proj1");
+            expect(result.content[0].text).toBe(JSON.stringify({ id: 1, name: "New Test Plan" }, null, 2));
+        });
+    });
+    describe("list_test_cases tool", () => {
+        it("should call getTestCaseList with the correct parameters and return the expected result", async () => {
+            configureTestPlanTools(server, tokenProvider, connectionProvider);
+            const call = server.tool.mock.calls.find(([toolName]) => toolName === "ado_list_test_cases");
+            if (!call)
+                throw new Error("ado_list_test_cases tool not registered");
+            const [, , , handler] = call;
+            mockTestPlanApi.getTestCaseList.mockResolvedValue([{ id: 1, name: "Test Case 1" }]);
+            const params = {
+                project: "proj1",
+                planid: 1,
+                suiteid: 2,
+            };
+            const result = await handler(params);
+            expect(mockTestPlanApi.getTestCaseList).toHaveBeenCalledWith("proj1", 1, 2);
+            expect(result.content[0].text).toBe(JSON.stringify([{ id: 1, name: "Test Case 1" }], null, 2));
+        });
+    });
+    describe("test_results_from_build_id tool", () => {
+        it("should call getTestResultDetailsForBuild with the correct parameters and return the expected result", async () => {
+            configureTestPlanTools(server, tokenProvider, connectionProvider);
+            const call = server.tool.mock.calls.find(([toolName]) => toolName === "ado_show_test_results_from_build_id");
+            if (!call)
+                throw new Error("ado_show_test_results_from_build_id tool not registered");
+            const [, , , handler] = call;
+            mockTestResultsApi.getTestResultDetailsForBuild.mockResolvedValue({ results: ["Result 1"] });
+            const params = {
+                project: "proj1",
+                buildid: 123,
+            };
+            const result = await handler(params);
+            expect(mockTestResultsApi.getTestResultDetailsForBuild).toHaveBeenCalledWith("proj1", 123);
+            expect(result.content[0].text).toBe(JSON.stringify({ results: ["Result 1"] }, null, 2));
+        });
+    });
+});

package/dist/tools/testplans.js

@@ -79,7 +79,7 @@ function configureTestPlanTools(server, tokenProvider, connectionProvider) {
     server.tool(Test_Plan_Tools.create_test_case, "Creates a new test case work item.", {
         project: z.string().describe("The unique identifier (ID or name) of the Azure DevOps project."),
         title: z.string().describe("The title of the test case."),
-        steps: z.string().optional().describe("The steps to reproduce the test case. Make sure to format each step as '1. Step one\\n2. Step two' etc."),
+        steps: z.string().optional().describe("The steps to reproduce the test case. Make sure to format each step as '1. Step one|Expected result one\n2. Step two|Expected result two"),
         priority: z.number().optional().describe("The priority of the test case."),
         areaPath: z.string().optional().describe("The area path for the test case."),
         iterationPath: z.string().optional().describe("The iteration path for the test case."),
@@ -165,17 +165,21 @@ function configureTestPlanTools(server, tokenProvider, connectionProvider) {
  * Helper function to convert steps text to XML format required
  */
 function convertStepsToXml(steps) {
+    // Accepts steps in the format: '1. Step one|Expected result one\n2. Step two|Expected result two'
     const stepsLines = steps.split("\n").filter((line) => line.trim() !== "");
     let xmlSteps = `<steps id="0" last="${stepsLines.length}">`;
     for (let i = 0; i < stepsLines.length; i++) {
         const stepLine = stepsLines[i].trim();
         if (stepLine) {
-            const stepMatch = stepLine.match(/^(\d+)\.\s*(.+)$/);
-            const stepText = stepMatch ? stepMatch[2] : stepLine;
+            // Split step and expected result by '|', fallback to default if not provided
+            const [stepPart, expectedPart] = stepLine.split("|").map((s) => s.trim());
+            const stepMatch = stepPart.match(/^(\d+)\.\s*(.+)$/);
+            const stepText = stepMatch ? stepMatch[2] : stepPart;
+            const expectedText = expectedPart || "Verify step completes successfully";
             xmlSteps += `
                 <step id="${i + 1}" type="ActionStep">
                     <parameterizedString isformatted="true">${escapeXml(stepText)}</parameterizedString>
-                    <parameterizedString isformatted="true">Verify step completes successfully</parameterizedString>
+                    <parameterizedString isformatted="true">${escapeXml(expectedText)}</parameterizedString>
                 </step>`;
         }
     }

package/dist/tools/utils.js

@@ -0,0 +1,6 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+import { packageVersion } from "./version.js";
+export const apiVersion = "7.2-preview.1";
+export const batchApiVersion = "5.0";
+export const userAgent = `AzureDevOps.MCP/${packageVersion} (local)`;

package/dist/tools/wiki.test.js

@@ -0,0 +1,87 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+import { describe, expect, it } from '@jest/globals';
+import { configureWikiTools } from '../../../src/tools/wiki';
+describe("configureWikiTools", () => {
+    let server;
+    let tokenProvider;
+    let connectionProvider;
+    let mockConnection;
+    let mockWikiApi;
+    beforeEach(() => {
+        server = { tool: jest.fn() };
+        tokenProvider = jest.fn();
+        mockWikiApi = {
+            getWiki: jest.fn(),
+            getAllWikis: jest.fn(),
+            getPagesBatch: jest.fn(),
+            getPageText: jest.fn(),
+        };
+        mockConnection = {
+            getWikiApi: jest.fn().mockResolvedValue(mockWikiApi),
+        };
+        connectionProvider = jest.fn().mockResolvedValue(mockConnection);
+    });
+    describe("tool registration", () => {
+        it("registers wiki tools on the server", () => {
+            configureWikiTools(server, tokenProvider, connectionProvider);
+            expect(server.tool).toHaveBeenCalled();
+        });
+    });
+    describe("get_wiki_page_content tool", () => {
+        it("should call getPageText with the correct parameters and return the expected result", async () => {
+            configureWikiTools(server, tokenProvider, connectionProvider);
+            const call = server.tool.mock.calls.find(([toolName]) => toolName === "ado_get_wiki_page_content");
+            if (!call)
+                throw new Error("ado_get_wiki_page_content tool not registered");
+            const [, , , handler] = call;
+            // Mock a stream-like object for getPageText
+            const mockStream = {
+                setEncoding: jest.fn(),
+                on: function (event, cb) {
+                    if (event === "data") {
+                        setImmediate(() => cb("mock page text"));
+                    }
+                    if (event === "end") {
+                        setImmediate(() => cb());
+                    }
+                    return this;
+                }
+            };
+            mockWikiApi.getPageText.mockResolvedValue(mockStream);
+            const params = {
+                wikiIdentifier: "wiki1",
+                project: "proj1",
+                path: "/page1"
+            };
+            const result = await handler(params);
+            expect(mockWikiApi.getPageText).toHaveBeenCalledWith("proj1", "wiki1", "/page1", undefined, undefined, true);
+            expect(result.content[0].text).toBe("\"mock page text\"");
+        });
+    });
+    describe("list_wiki_pages tool", () => {
+        it("should call getPagesBatch with the correct parameters and return the expected result", async () => {
+            configureWikiTools(server, tokenProvider, connectionProvider);
+            const call = server.tool.mock.calls.find(([toolName]) => toolName === "ado_list_wiki_pages");
+            if (!call)
+                throw new Error("ado_list_wiki_pages tool not registered");
+            const [, , , handler] = call;
+            mockWikiApi.getPagesBatch.mockResolvedValue({ value: ["page1", "page2"] });
+            const params = {
+                wikiIdentifier: "wiki2",
+                project: "proj2",
+                top: 10,
+                continuationToken: "token123",
+                pageViewsForDays: 7
+            };
+            const result = await handler(params);
+            const parsedResult = JSON.parse(result.content[0].text);
+            expect(mockWikiApi.getPagesBatch).toHaveBeenCalledWith({
+                top: 10,
+                continuationToken: "token123",
+                pageViewsForDays: 7
+            }, "proj2", "wiki2");
+            expect(parsedResult.value).toEqual(["page1", "page2"]);
+        });
+    });
+});