feat: add repository tree and branch/commit tools

Author: hmaldonadovilla

src/features/pull-requests/get-pull-request-changes/feature.spec.unit.ts

@@ -0,0 +1,43 @@
+import { getPullRequestChanges } from './feature';
+import { AzureDevOpsError } from '../../../shared/errors';
+
+describe('getPullRequestChanges unit', () => {
+  test('should retrieve changes and evaluations', async () => {
+    const mockConnection: any = {
+      getGitApi: jest.fn().mockResolvedValue({
+        getPullRequestIterations: jest.fn().mockResolvedValue([{ id: 1 }]),
+        getPullRequestIterationChanges: jest
+          .fn()
+          .mockResolvedValue({ changeEntries: [] }),
+      }),
+      getPolicyApi: jest.fn().mockResolvedValue({
+        getPolicyEvaluations: jest.fn().mockResolvedValue([{ id: '1' }]),
+      }),
+    };
+
+    const result = await getPullRequestChanges(mockConnection, {
+      projectId: 'p',
+      repositoryId: 'r',
+      pullRequestId: 1,
+    });
+
+    expect(result.changes).toEqual({ changeEntries: [] });
+    expect(result.evaluations).toHaveLength(1);
+  });
+
+  test('should throw when no iterations found', async () => {
+    const mockConnection: any = {
+      getGitApi: jest.fn().mockResolvedValue({
+        getPullRequestIterations: jest.fn().mockResolvedValue([]),
+      }),
+    };
+
+    await expect(
+      getPullRequestChanges(mockConnection, {
+        projectId: 'p',
+        repositoryId: 'r',
+        pullRequestId: 1,
+      }),
+    ).rejects.toThrow(AzureDevOpsError);
+  });
+});

src/features/pull-requests/get-pull-request-changes/feature.ts

@@ -0,0 +1,58 @@
+import { WebApi } from 'azure-devops-node-api';
+import { GitPullRequestIterationChanges } from 'azure-devops-node-api/interfaces/GitInterfaces';
+import { PolicyEvaluationRecord } from 'azure-devops-node-api/interfaces/PolicyInterfaces';
+import { AzureDevOpsError } from '../../../shared/errors';
+
+export interface PullRequestChangesOptions {
+  projectId: string;
+  repositoryId: string;
+  pullRequestId: number;
+}
+
+export interface PullRequestChangesResponse {
+  changes: GitPullRequestIterationChanges;
+  evaluations: PolicyEvaluationRecord[];
+}
+
+/**
+ * Retrieve changes and policy evaluation status for a pull request
+ */
+export async function getPullRequestChanges(
+  connection: WebApi,
+  options: PullRequestChangesOptions,
+): Promise<PullRequestChangesResponse> {
+  try {
+    const gitApi = await connection.getGitApi();
+    const iterations = await gitApi.getPullRequestIterations(
+      options.repositoryId,
+      options.pullRequestId,
+      options.projectId,
+    );
+    if (!iterations || iterations.length === 0) {
+      throw new AzureDevOpsError('No iterations found for pull request');
+    }
+    const latest = iterations[iterations.length - 1];
+    const changes = await gitApi.getPullRequestIterationChanges(
+      options.repositoryId,
+      options.pullRequestId,
+      latest.id!,
+      options.projectId,
+    );
+
+    const policyApi = await connection.getPolicyApi();
+    const artifactId = `vstfs:///CodeReview/CodeReviewId/${options.projectId}/${options.pullRequestId}`;
+    const evaluations = await policyApi.getPolicyEvaluations(
+      options.projectId,
+      artifactId,
+    );
+
+    return { changes, evaluations };
+  } catch (error) {
+    if (error instanceof AzureDevOpsError) {
+      throw error;
+    }
+    throw new Error(
+      `Failed to get pull request changes: ${error instanceof Error ? error.message : String(error)}`,
+    );
+  }
+}

src/features/pull-requests/get-pull-request-changes/index.ts

@@ -0,0 +1 @@
+export * from './feature';

src/features/pull-requests/index.spec.unit.ts

@@ -6,6 +6,7 @@ import { listPullRequests } from './list-pull-requests';
 import { getPullRequestComments } from './get-pull-request-comments';
 import { addPullRequestComment } from './add-pull-request-comment';
 import { AddPullRequestCommentSchema } from './schemas';
+import { getPullRequestChanges } from './get-pull-request-changes';
 
 // Mock the imported modules
 jest.mock('./create-pull-request', () => ({
@@ -24,6 +25,10 @@ jest.mock('./add-pull-request-comment', () => ({
   addPullRequestComment: jest.fn(),
 }));
 
+jest.mock('./get-pull-request-changes', () => ({
+  getPullRequestChanges: jest.fn(),
+}));
+
 describe('Pull Requests Request Handlers', () => {
   const mockConnection = {} as WebApi;
 
@@ -34,6 +39,7 @@ describe('Pull Requests Request Handlers', () => {
         'list_pull_requests',
         'get_pull_request_comments',
         'add_pull_request_comment',
+        'get_pull_request_changes',
       ];
       validTools.forEach((tool) => {
         const request = {
@@ -216,6 +222,25 @@ describe('Pull Requests Request Handlers', () => {
       AddPullRequestCommentSchema.parse = originalParse;
     });
 
+    it('should handle get_pull_request_changes request', async () => {
+      const mockResult = { changes: { changeEntries: [] }, evaluations: [] };
+      (getPullRequestChanges as jest.Mock).mockResolvedValue(mockResult);
+
+      const request = {
+        params: {
+          name: 'get_pull_request_changes',
+          arguments: { repositoryId: 'test-repo', pullRequestId: 1 },
+        },
+        method: 'tools/call',
+      } as CallToolRequest;
+
+      const response = await handlePullRequestsRequest(mockConnection, request);
+      expect(JSON.parse(response.content[0].text as string)).toEqual(
+        mockResult,
+      );
+      expect(getPullRequestChanges).toHaveBeenCalled();
+    });
+
     it('should throw error for unknown tool', async () => {
       const request = {
         params: {

src/features/pull-requests/index.ts

@@ -5,6 +5,7 @@ export * from './list-pull-requests';
 export * from './get-pull-request-comments';
 export * from './add-pull-request-comment';
 export * from './update-pull-request';
+export * from './get-pull-request-changes';
 
 // Export tool definitions
 export * from './tool-definitions';
@@ -23,11 +24,13 @@ import {
   GetPullRequestCommentsSchema,
   AddPullRequestCommentSchema,
   UpdatePullRequestSchema,
+  GetPullRequestChangesSchema,
   createPullRequest,
   listPullRequests,
   getPullRequestComments,
   addPullRequestComment,
   updatePullRequest,
+  getPullRequestChanges,
 } from './';
 
 /**
@@ -43,6 +46,7 @@ export const isPullRequestsRequest: RequestIdentifier = (
     'get_pull_request_comments',
     'add_pull_request_comment',
     'update_pull_request',
+    'get_pull_request_changes',
   ].includes(toolName);
 };
 
@@ -146,6 +150,19 @@ export const handlePullRequestsRequest: RequestHandler = async (
         content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
       };
     }
+    case 'get_pull_request_changes': {
+      const params = GetPullRequestChangesSchema.parse(
+        request.params.arguments,
+      );
+      const result = await getPullRequestChanges(connection, {
+        projectId: params.projectId ?? defaultProject,
+        repositoryId: params.repositoryId,
+        pullRequestId: params.pullRequestId,
+      });
+      return {
+        content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+      };
+    }
     default:
       throw new Error(`Unknown pull requests tool: ${request.params.name}`);
   }

src/features/pull-requests/schemas.ts

@@ -219,3 +219,19 @@ export const UpdatePullRequestSchema = z.object({
     .optional()
     .describe('Additional properties to update on the pull request'),
 });
+
+/**
+ * Schema for getting pull request changes and policy evaluations
+ */
+export const GetPullRequestChangesSchema = z.object({
+  projectId: z
+    .string()
+    .optional()
+    .describe(`The ID or name of the project (Default: ${defaultProject})`),
+  organizationId: z
+    .string()
+    .optional()
+    .describe(`The ID or name of the organization (Default: ${defaultOrg})`),
+  repositoryId: z.string().describe('The ID or name of the repository'),
+  pullRequestId: z.number().describe('The ID of the pull request'),
+});

src/features/pull-requests/tool-definitions.ts

@@ -6,6 +6,7 @@ import {
   GetPullRequestCommentsSchema,
   AddPullRequestCommentSchema,
   UpdatePullRequestSchema,
+  GetPullRequestChangesSchema,
 } from './schemas';
 
 /**
@@ -39,4 +40,10 @@ export const pullRequestsTools: ToolDefinition[] = [
       'Update an existing pull request with new properties, link work items, and manage reviewers',
     inputSchema: zodToJsonSchema(UpdatePullRequestSchema),
   },
+  {
+    name: 'get_pull_request_changes',
+    description:
+      'Get the files changed in a pull request and the status of policy evaluations',
+    inputSchema: zodToJsonSchema(GetPullRequestChangesSchema),
+  },
 ];

src/features/repositories/create-branch/feature.spec.unit.ts

@@ -0,0 +1,40 @@
+import { createBranch } from './feature';
+import { AzureDevOpsError } from '../../../shared/errors';
+
+describe('createBranch unit', () => {
+  test('should create branch when source exists', async () => {
+    const updateRefs = jest.fn().mockResolvedValue([{ success: true }]);
+    const mockConnection: any = {
+      getGitApi: jest.fn().mockResolvedValue({
+        getBranch: jest.fn().mockResolvedValue({ commit: { commitId: 'abc' } }),
+        updateRefs,
+      }),
+    };
+
+    await createBranch(mockConnection, {
+      projectId: 'p',
+      repositoryId: 'r',
+      sourceBranch: 'main',
+      newBranch: 'feature',
+    });
+
+    expect(updateRefs).toHaveBeenCalled();
+  });
+
+  test('should throw error when source branch missing', async () => {
+    const mockConnection: any = {
+      getGitApi: jest.fn().mockResolvedValue({
+        getBranch: jest.fn().mockResolvedValue(null),
+      }),
+    };
+
+    await expect(
+      createBranch(mockConnection, {
+        projectId: 'p',
+        repositoryId: 'r',
+        sourceBranch: 'missing',
+        newBranch: 'feature',
+      }),
+    ).rejects.toThrow(AzureDevOpsError);
+  });
+});

src/features/repositories/create-branch/feature.ts

@@ -0,0 +1,49 @@
+import { WebApi } from 'azure-devops-node-api';
+import { GitRefUpdate } from 'azure-devops-node-api/interfaces/GitInterfaces';
+import { AzureDevOpsError } from '../../../shared/errors';
+import { CreateBranchOptions } from '../types';
+
+/**
+ * Create a new branch from an existing one
+ */
+export async function createBranch(
+  connection: WebApi,
+  options: CreateBranchOptions,
+): Promise<void> {
+  try {
+    const gitApi = await connection.getGitApi();
+    const source = await gitApi.getBranch(
+      options.repositoryId,
+      options.sourceBranch,
+      options.projectId,
+    );
+    const commitId = source?.commit?.commitId;
+    if (!commitId) {
+      throw new AzureDevOpsError(
+        `Source branch '${options.sourceBranch}' not found`,
+      );
+    }
+
+    const refUpdate: GitRefUpdate = {
+      name: `refs/heads/${options.newBranch}`,
+      oldObjectId: '0000000000000000000000000000000000000000',
+      newObjectId: commitId,
+    };
+
+    const result = await gitApi.updateRefs(
+      [refUpdate],
+      options.repositoryId,
+      options.projectId,
+    );
+    if (!result.every((r) => r.success)) {
+      throw new AzureDevOpsError('Failed to create new branch');
+    }
+  } catch (error) {
+    if (error instanceof AzureDevOpsError) {
+      throw error;
+    }
+    throw new Error(
+      `Failed to create branch: ${error instanceof Error ? error.message : String(error)}`,
+    );
+  }
+}

src/features/repositories/create-branch/index.ts

@@ -0,0 +1 @@
+export * from './feature';