@azure-devops/mcp 1.3.1 → 2.0.0-nightly.20250825

package/dist/tools/wiki.js

@@ -6,6 +6,7 @@ const WIKI_TOOLS = {
     get_wiki: "wiki_get_wiki",
     list_wiki_pages: "wiki_list_pages",
     get_wiki_page_content: "wiki_get_page_content",
+    create_or_update_page: "wiki_create_or_update_page",
 };
 function configureWikiTools(server, tokenProvider, connectionProvider) {
     server.tool(WIKI_TOOLS.get_wiki, "Get the wiki by wikiIdentifier", {
@@ -84,27 +85,191 @@ function configureWikiTools(server, tokenProvider, connectionProvider) {
             };
         }
     });
-    server.tool(WIKI_TOOLS.get_wiki_page_content, "Retrieve wiki page content by wikiIdentifier and path.", {
-        wikiIdentifier: z.string().describe("The unique identifier of the wiki."),
-        project: z.string().describe("The project name or ID where the wiki is located."),
-        path: z.string().describe("The path of the wiki page to retrieve content for."),
-    }, async ({ wikiIdentifier, project, path }) => {
+    server.tool(WIKI_TOOLS.get_wiki_page_content, "Retrieve wiki page content. Provide either a 'url' parameter OR the combination of 'wikiIdentifier' and 'project' parameters.", {
+        url: z
+            .string()
+            .optional()
+            .describe("The full URL of the wiki page to retrieve content for. If provided, wikiIdentifier, project, and path are ignored. Supported patterns: https://dev.azure.com/{org}/{project}/_wiki/wikis/{wikiIdentifier}?pagePath=%2FMy%20Page and https://dev.azure.com/{org}/{project}/_wiki/wikis/{wikiIdentifier}/{pageId}/Page-Title"),
+        wikiIdentifier: z.string().optional().describe("The unique identifier of the wiki. Required if url is not provided."),
+        project: z.string().optional().describe("The project name or ID where the wiki is located. Required if url is not provided."),
+        path: z.string().optional().describe("The path of the wiki page to retrieve content for. Optional, defaults to root page if not provided."),
+    }, async ({ url, wikiIdentifier, project, path }) => {
         try {
+            const hasUrl = !!url;
+            const hasPair = !!wikiIdentifier && !!project;
+            if (hasUrl && hasPair) {
+                return { content: [{ type: "text", text: "Error fetching wiki page content: Provide either 'url' OR 'wikiIdentifier' with 'project', not both." }], isError: true };
+            }
+            if (!hasUrl && !hasPair) {
+                return { content: [{ type: "text", text: "Error fetching wiki page content: You must provide either 'url' OR both 'wikiIdentifier' and 'project'." }], isError: true };
+            }
             const connection = await connectionProvider();
             const wikiApi = await connection.getWikiApi();
-            const stream = await wikiApi.getPageText(project, wikiIdentifier, path, undefined, undefined, true);
-            if (!stream) {
-                return { content: [{ type: "text", text: "No wiki page content found" }], isError: true };
+            let resolvedProject = project;
+            let resolvedWiki = wikiIdentifier;
+            let resolvedPath = path;
+            let pageContent;
+            if (url) {
+                const parsed = parseWikiUrl(url);
+                if ("error" in parsed) {
+                    return { content: [{ type: "text", text: `Error fetching wiki page content: ${parsed.error}` }], isError: true };
+                }
+                resolvedProject = parsed.project;
+                resolvedWiki = parsed.wikiIdentifier;
+                if (parsed.pagePath) {
+                    resolvedPath = parsed.pagePath;
+                }
+                if (parsed.pageId) {
+                    try {
+                        let accessToken;
+                        try {
+                            accessToken = await tokenProvider();
+                        }
+                        catch { }
+                        const baseUrl = connection.serverUrl.replace(/\/$/, "");
+                        const restUrl = `${baseUrl}/${resolvedProject}/_apis/wiki/wikis/${resolvedWiki}/pages/${parsed.pageId}?includeContent=true&api-version=7.1`;
+                        const resp = await fetch(restUrl, {
+                            headers: accessToken?.token ? { Authorization: `Bearer ${accessToken.token}` } : {},
+                        });
+                        if (resp.ok) {
+                            const json = await resp.json();
+                            if (json && typeof json.content === "string") {
+                                pageContent = json.content;
+                            }
+                            else if (json && json.path) {
+                                resolvedPath = json.path;
+                            }
+                        }
+                        else if (resp.status === 404) {
+                            return { content: [{ type: "text", text: `Error fetching wiki page content: Page with id ${parsed.pageId} not found` }], isError: true };
+                        }
+                    }
+                    catch { }
+                }
+            }
+            if (!pageContent) {
+                if (!resolvedPath) {
+                    resolvedPath = "/";
+                }
+                if (!resolvedProject || !resolvedWiki) {
+                    return { content: [{ type: "text", text: "Project and wikiIdentifier must be defined to fetch wiki page content." }], isError: true };
+                }
+                const stream = await wikiApi.getPageText(resolvedProject, resolvedWiki, resolvedPath, undefined, undefined, true);
+                if (!stream) {
+                    return { content: [{ type: "text", text: "No wiki page content found" }], isError: true };
+                }
+                pageContent = await streamToString(stream);
             }
-            const content = await streamToString(stream);
+            return { content: [{ type: "text", text: JSON.stringify(pageContent, null, 2) }] };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
             return {
-                content: [{ type: "text", text: JSON.stringify(content, null, 2) }],
+                content: [{ type: "text", text: `Error fetching wiki page content: ${errorMessage}` }],
+                isError: true,
             };
         }
+    });
+    server.tool(WIKI_TOOLS.create_or_update_page, "Create or update a wiki page with content.", {
+        wikiIdentifier: z.string().describe("The unique identifier or name of the wiki."),
+        path: z.string().describe("The path of the wiki page (e.g., '/Home' or '/Documentation/Setup')."),
+        content: z.string().describe("The content of the wiki page in markdown format."),
+        project: z.string().optional().describe("The project name or ID where the wiki is located. If not provided, the default project will be used."),
+        etag: z.string().optional().describe("ETag for editing existing pages (optional, will be fetched if not provided)."),
+    }, async ({ wikiIdentifier, path, content, project, etag }) => {
+        try {
+            const connection = await connectionProvider();
+            const accessToken = await tokenProvider();
+            // Normalize the path
+            const normalizedPath = path.startsWith("/") ? path : `/${path}`;
+            const encodedPath = encodeURIComponent(normalizedPath);
+            // Build the URL for the wiki page API
+            const baseUrl = connection.serverUrl;
+            const projectParam = project || "";
+            const url = `${baseUrl}/${projectParam}/_apis/wiki/wikis/${wikiIdentifier}/pages?path=${encodedPath}&api-version=7.1`;
+            // First, try to create a new page (PUT without ETag)
+            try {
+                const createResponse = await fetch(url, {
+                    method: "PUT",
+                    headers: {
+                        "Authorization": `Bearer ${accessToken.token}`,
+                        "Content-Type": "application/json",
+                    },
+                    body: JSON.stringify({ content: content }),
+                });
+                if (createResponse.ok) {
+                    const result = await createResponse.json();
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `Successfully created wiki page at path: ${normalizedPath}. Response: ${JSON.stringify(result, null, 2)}`,
+                            },
+                        ],
+                    };
+                }
+                // If creation failed with 409 (Conflict) or 500 (Page exists), try to update it
+                if (createResponse.status === 409 || createResponse.status === 500) {
+                    // Page exists, we need to get the ETag and update it
+                    let currentEtag = etag;
+                    if (!currentEtag) {
+                        // Fetch current page to get ETag
+                        const getResponse = await fetch(url, {
+                            method: "GET",
+                            headers: {
+                                Authorization: `Bearer ${accessToken.token}`,
+                            },
+                        });
+                        if (getResponse.ok) {
+                            currentEtag = getResponse.headers.get("etag") || getResponse.headers.get("ETag") || undefined;
+                            if (!currentEtag) {
+                                const pageData = await getResponse.json();
+                                currentEtag = pageData.eTag;
+                            }
+                        }
+                        if (!currentEtag) {
+                            throw new Error("Could not retrieve ETag for existing page");
+                        }
+                    }
+                    // Now update the existing page with ETag
+                    const updateResponse = await fetch(url, {
+                        method: "PUT",
+                        headers: {
+                            "Authorization": `Bearer ${accessToken.token}`,
+                            "Content-Type": "application/json",
+                            "If-Match": currentEtag,
+                        },
+                        body: JSON.stringify({ content: content }),
+                    });
+                    if (updateResponse.ok) {
+                        const result = await updateResponse.json();
+                        return {
+                            content: [
+                                {
+                                    type: "text",
+                                    text: `Successfully updated wiki page at path: ${normalizedPath}. Response: ${JSON.stringify(result, null, 2)}`,
+                                },
+                            ],
+                        };
+                    }
+                    else {
+                        const errorText = await updateResponse.text();
+                        throw new Error(`Failed to update page (${updateResponse.status}): ${errorText}`);
+                    }
+                }
+                else {
+                    const errorText = await createResponse.text();
+                    throw new Error(`Failed to create page (${createResponse.status}): ${errorText}`);
+                }
+            }
+            catch (fetchError) {
+                throw fetchError;
+            }
+        }
         catch (error) {
             const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
             return {
-                content: [{ type: "text", text: `Error fetching wiki page content: ${errorMessage}` }],
+                content: [{ type: "text", text: `Error creating/updating wiki page: ${errorMessage}` }],
                 isError: true,
             };
         }
@@ -119,4 +284,47 @@ function streamToString(stream) {
         stream.on("error", reject);
     });
 }
+// Helper to parse Azure DevOps wiki page URLs.
+// Supported examples:
+//  - https://dev.azure.com/org/project/_wiki/wikis/wikiIdentifier?wikiVersion=GBmain&pagePath=%2FHome
+//  - https://dev.azure.com/org/project/_wiki/wikis/wikiIdentifier/123/Title-Of-Page
+// Returns either a structured object OR an error message inside { error }.
+function parseWikiUrl(url) {
+    try {
+        const u = new URL(url);
+        // Path segments after host
+        // Expect pattern: /{project}/_wiki/wikis/{wikiIdentifier}[/{pageId}/...]
+        const segments = u.pathname.split("/").filter(Boolean); // remove empty
+        const idx = segments.findIndex((s) => s === "_wiki");
+        if (idx < 1 || segments[idx + 1] !== "wikis") {
+            return { error: "URL does not match expected wiki pattern (missing /_wiki/wikis/ segment)." };
+        }
+        const project = segments[idx - 1];
+        const wikiIdentifier = segments[idx + 2];
+        if (!project || !wikiIdentifier) {
+            return { error: "Could not extract project or wikiIdentifier from URL." };
+        }
+        // Query form with pagePath
+        const pagePathParam = u.searchParams.get("pagePath");
+        if (pagePathParam) {
+            let decoded = decodeURIComponent(pagePathParam);
+            if (!decoded.startsWith("/"))
+                decoded = "/" + decoded;
+            return { project, wikiIdentifier, pagePath: decoded };
+        }
+        // Path ID form: .../wikis/{wikiIdentifier}/{pageId}/...
+        const afterWiki = segments.slice(idx + 3); // elements after wikiIdentifier
+        if (afterWiki.length >= 1) {
+            const maybeId = parseInt(afterWiki[0], 10);
+            if (!isNaN(maybeId)) {
+                return { project, wikiIdentifier, pageId: maybeId };
+            }
+        }
+        // If nothing else specified, treat as root page
+        return { project, wikiIdentifier, pagePath: "/" };
+    }
+    catch {
+        return { error: "Invalid URL format." };
+    }
+}
 export { WIKI_TOOLS, configureWikiTools };

package/dist/tools/{workitems.js → work-items.js}

@@ -23,6 +23,7 @@ const WORKITEM_TOOLS = {
     update_work_items_batch: "wit_update_work_items_batch",
     work_items_link: "wit_work_items_link",
     work_item_unlink: "wit_work_item_unlink",
+    add_artifact_link: "wit_add_artifact_link",
 };
 function getLinkTypeFromName(name) {
     switch (name.toLowerCase()) {
@@ -96,20 +97,37 @@ function configureWorkItemTools(server, tokenProvider, connectionProvider, userA
     server.tool(WORKITEM_TOOLS.get_work_items_batch_by_ids, "Retrieve list of work items by IDs in batch.", {
         project: z.string().describe("The name or ID of the Azure DevOps project."),
         ids: z.array(z.number()).describe("The IDs of the work items to retrieve."),
-    }, async ({ project, ids }) => {
+        fields: z.array(z.string()).optional().describe("Optional list of fields to include in the response. If not provided, a hardcoded default set of fields will be used."),
+    }, async ({ project, ids, fields }) => {
         const connection = await connectionProvider();
         const workItemApi = await connection.getWorkItemTrackingApi();
-        const fields = ["System.Id", "System.WorkItemType", "System.Title", "System.State", "System.Parent", "System.Tags", "Microsoft.VSTS.Common.StackRank", "System.AssignedTo"];
-        const workitems = await workItemApi.getWorkItemsBatch({ ids, fields }, project);
-        // Format the assignedTo field to include displayName and uniqueName
+        const defaultFields = ["System.Id", "System.WorkItemType", "System.Title", "System.State", "System.Parent", "System.Tags", "Microsoft.VSTS.Common.StackRank", "System.AssignedTo"];
+        // If no fields are provided, use the default set of fields
+        const fieldsToUse = !fields || fields.length === 0 ? defaultFields : fields;
+        const workitems = await workItemApi.getWorkItemsBatch({ ids, fields: fieldsToUse }, project);
+        // List of identity fields that need to be transformed from objects to formatted strings
+        const identityFields = [
+            "System.AssignedTo",
+            "System.CreatedBy",
+            "System.ChangedBy",
+            "System.AuthorizedAs",
+            "Microsoft.VSTS.Common.ActivatedBy",
+            "Microsoft.VSTS.Common.ResolvedBy",
+            "Microsoft.VSTS.Common.ClosedBy",
+        ];
+        // Format identity fields to include displayName and uniqueName
         // Removing the identity object as the response. It's too much and not needed
         if (workitems && Array.isArray(workitems)) {
             workitems.forEach((item) => {
-                if (item.fields && item.fields["System.AssignedTo"] && typeof item.fields["System.AssignedTo"] === "object") {
-                    const assignedTo = item.fields["System.AssignedTo"];
-                    const name = assignedTo.displayName || "";
-                    const email = assignedTo.uniqueName || "";
-                    item.fields["System.AssignedTo"] = `${name} <${email}>`.trim();
+                if (item.fields) {
+                    identityFields.forEach((fieldName) => {
+                        if (item.fields && item.fields[fieldName] && typeof item.fields[fieldName] === "object") {
+                            const identityField = item.fields[fieldName];
+                            const name = identityField.displayName || "";
+                            const email = identityField.uniqueName || "";
+                            item.fields[fieldName] = `${name} <${email}>`.trim();
+                        }
+                    });
                 }
             });
         }
@@ -126,7 +144,7 @@ function configureWorkItemTools(server, tokenProvider, connectionProvider, userA
             .enum(["all", "fields", "links", "none", "relations"])
             .describe("Optional expand parameter to include additional details in the response.")
             .optional()
-            .describe("Expand options include 'all', 'fields', 'links', 'none', and 'relations'. Defaults to 'none'."),
+            .describe("Expand options include 'all', 'fields', 'links', 'none', and 'relations'. Relations can be used to get child workitems. Defaults to 'none'."),
     }, async ({ id, project, fields, asOf, expand }) => {
         const connection = await connectionProvider();
         const workItemApi = await connection.getWorkItemTrackingApi();
@@ -655,5 +673,137 @@ function configureWorkItemTools(server, tokenProvider, connectionProvider, userA
             };
         }
     });
+    server.tool(WORKITEM_TOOLS.add_artifact_link, "Add artifact links (repository, branch, commit, builds) to work items. You can either provide the full vstfs URI or the individual components to build it automatically.", {
+        workItemId: z.number().describe("The ID of the work item to add the artifact link to."),
+        project: z.string().describe("The name or ID of the Azure DevOps project."),
+        // Option 1: Provide full URI directly
+        artifactUri: z.string().optional().describe("The complete VSTFS URI of the artifact to link. If provided, individual component parameters are ignored."),
+        // Option 2: Provide individual components to build URI automatically based on linkType
+        projectId: z.string().optional().describe("The project ID (GUID) containing the artifact. Required for Git artifacts when artifactUri is not provided."),
+        repositoryId: z.string().optional().describe("The repository ID (GUID) containing the artifact. Required for Git artifacts when artifactUri is not provided."),
+        branchName: z.string().optional().describe("The branch name (e.g., 'main'). Required when linkType is 'Branch'."),
+        commitId: z.string().optional().describe("The commit SHA hash. Required when linkType is 'Fixed in Commit'."),
+        pullRequestId: z.number().optional().describe("The pull request ID. Required when linkType is 'Pull Request'."),
+        buildId: z.number().optional().describe("The build ID. Required when linkType is 'Build', 'Found in build', or 'Integrated in build'."),
+        linkType: z
+            .enum([
+            "Branch",
+            "Build",
+            "Fixed in Changeset",
+            "Fixed in Commit",
+            "Found in build",
+            "Integrated in build",
+            "Model Link",
+            "Pull Request",
+            "Related Workitem",
+            "Result Attachment",
+            "Source Code File",
+            "Tag",
+            "Test Result",
+            "Wiki",
+        ])
+            .default("Branch")
+            .describe("Type of artifact link, defaults to 'Branch'. This determines both the link type and how to build the VSTFS URI from individual components."),
+        comment: z.string().optional().describe("Comment to include with the artifact link."),
+    }, async ({ workItemId, project, artifactUri, projectId, repositoryId, branchName, commitId, pullRequestId, buildId, linkType, comment }) => {
+        try {
+            const connection = await connectionProvider();
+            const workItemTrackingApi = await connection.getWorkItemTrackingApi();
+            let finalArtifactUri;
+            if (artifactUri) {
+                // Use the provided full URI
+                finalArtifactUri = artifactUri;
+            }
+            else {
+                // Build the URI from individual components based on linkType
+                switch (linkType) {
+                    case "Branch":
+                        if (!projectId || !repositoryId || !branchName) {
+                            return {
+                                content: [{ type: "text", text: "For 'Branch' links, 'projectId', 'repositoryId', and 'branchName' are required." }],
+                                isError: true,
+                            };
+                        }
+                        finalArtifactUri = `vstfs:///Git/Ref/${encodeURIComponent(projectId)}%2F${encodeURIComponent(repositoryId)}%2FGB${encodeURIComponent(branchName)}`;
+                        break;
+                    case "Fixed in Commit":
+                        if (!projectId || !repositoryId || !commitId) {
+                            return {
+                                content: [{ type: "text", text: "For 'Fixed in Commit' links, 'projectId', 'repositoryId', and 'commitId' are required." }],
+                                isError: true,
+                            };
+                        }
+                        finalArtifactUri = `vstfs:///Git/Commit/${encodeURIComponent(projectId)}%2F${encodeURIComponent(repositoryId)}%2F${encodeURIComponent(commitId)}`;
+                        break;
+                    case "Pull Request":
+                        if (!projectId || !repositoryId || pullRequestId === undefined) {
+                            return {
+                                content: [{ type: "text", text: "For 'Pull Request' links, 'projectId', 'repositoryId', and 'pullRequestId' are required." }],
+                                isError: true,
+                            };
+                        }
+                        finalArtifactUri = `vstfs:///Git/PullRequestId/${encodeURIComponent(projectId)}%2F${encodeURIComponent(repositoryId)}%2F${encodeURIComponent(pullRequestId.toString())}`;
+                        break;
+                    case "Build":
+                    case "Found in build":
+                    case "Integrated in build":
+                        if (buildId === undefined) {
+                            return {
+                                content: [{ type: "text", text: `For '${linkType}' links, 'buildId' is required.` }],
+                                isError: true,
+                            };
+                        }
+                        finalArtifactUri = `vstfs:///Build/Build/${encodeURIComponent(buildId.toString())}`;
+                        break;
+                    default:
+                        return {
+                            content: [{ type: "text", text: `URI building from components is not supported for link type '${linkType}'. Please provide the full 'artifactUri' instead.` }],
+                            isError: true,
+                        };
+                }
+            }
+            // Create the patch document for adding an artifact link relation
+            const patchDocument = [
+                {
+                    op: "add",
+                    path: "/relations/-",
+                    value: {
+                        rel: "ArtifactLink",
+                        url: finalArtifactUri,
+                        attributes: {
+                            name: linkType,
+                            ...(comment && { comment }),
+                        },
+                    },
+                },
+            ];
+            // Use the WorkItem API to update the work item with the new relation
+            const workItem = await workItemTrackingApi.updateWorkItem({}, patchDocument, workItemId, project);
+            if (!workItem) {
+                return { content: [{ type: "text", text: "Work item update failed" }], isError: true };
+            }
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({
+                            workItemId,
+                            artifactUri: finalArtifactUri,
+                            linkType,
+                            comment: comment || null,
+                            success: true,
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
+            return {
+                content: [{ type: "text", text: `Error adding artifact link to work item: ${errorMessage}` }],
+                isError: true,
+            };
+        }
+    });
 }
 export { WORKITEM_TOOLS, configureWorkItemTools };

package/dist/tools.js

@@ -1,25 +1,31 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
-import { configureAdvSecTools } from "./tools/advsec.js";
+import { Domain } from "./shared/domains.js";
+import { configureAdvSecTools } from "./tools/advanced-security.js";
 import { configureBuildTools } from "./tools/builds.js";
 import { configureCoreTools } from "./tools/core.js";
 import { configureReleaseTools } from "./tools/releases.js";
-import { configureRepoTools } from "./tools/repos.js";
+import { configureRepoTools } from "./tools/repositories.js";
 import { configureSearchTools } from "./tools/search.js";
-import { configureTestPlanTools } from "./tools/testplans.js";
+import { configureTestPlanTools } from "./tools/test-plans.js";
 import { configureWikiTools } from "./tools/wiki.js";
 import { configureWorkTools } from "./tools/work.js";
-import { configureWorkItemTools } from "./tools/workitems.js";
-function configureAllTools(server, tokenProvider, connectionProvider, userAgentProvider) {
-    configureCoreTools(server, tokenProvider, connectionProvider);
-    configureWorkTools(server, tokenProvider, connectionProvider);
-    configureBuildTools(server, tokenProvider, connectionProvider);
-    configureRepoTools(server, tokenProvider, connectionProvider);
-    configureWorkItemTools(server, tokenProvider, connectionProvider, userAgentProvider);
-    configureReleaseTools(server, tokenProvider, connectionProvider);
-    configureWikiTools(server, tokenProvider, connectionProvider);
-    configureTestPlanTools(server, tokenProvider, connectionProvider);
-    configureSearchTools(server, tokenProvider, connectionProvider, userAgentProvider);
-    configureAdvSecTools(server, tokenProvider, connectionProvider);
+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.WORK, () => configureWorkTools(server, tokenProvider, connectionProvider));
+    configureIfDomainEnabled(Domain.BUILDS, () => configureBuildTools(server, tokenProvider, connectionProvider, userAgentProvider));
+    configureIfDomainEnabled(Domain.REPOSITORIES, () => configureRepoTools(server, tokenProvider, connectionProvider, userAgentProvider));
+    configureIfDomainEnabled(Domain.WORK_ITEMS, () => configureWorkItemTools(server, tokenProvider, connectionProvider, userAgentProvider));
+    configureIfDomainEnabled(Domain.RELEASES, () => configureReleaseTools(server, tokenProvider, connectionProvider));
+    configureIfDomainEnabled(Domain.WIKI, () => configureWikiTools(server, tokenProvider, connectionProvider));
+    configureIfDomainEnabled(Domain.TEST_PLANS, () => configureTestPlanTools(server, tokenProvider, connectionProvider));
+    configureIfDomainEnabled(Domain.SEARCH, () => configureSearchTools(server, tokenProvider, connectionProvider, userAgentProvider));
+    configureIfDomainEnabled(Domain.ADVANCED_SECURITY, () => configureAdvSecTools(server, tokenProvider, connectionProvider));
 }
 export { configureAllTools };

package/dist/version.js

@@ -1 +1 @@
-export const packageVersion = "1.3.1";
+export const packageVersion = "2.0.0-nightly.20250825";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@azure-devops/mcp",
-  "version": "1.3.1",
+  "version": "2.0.0-nightly.20250825",
   "description": "MCP server for interacting with Azure DevOps",
   "license": "MIT",
   "author": "Microsoft Corporation",

package/dist/tools/core.test.js

@@ -1 +0,0 @@
-export {};