@atlassian-dc-mcp/bitbucket 0.6.0 → 0.7.0

package/src/bitbucket-service.ts

@@ -1,6 +1,9 @@
 import { z } from 'zod';
 import { OpenAPI, ProjectService, PullRequestsService, RepositoryService } from './bitbucket-client/index.js';
+import { request as __request } from './bitbucket-client/core/request.js';
 import { handleApiOperation } from '@atlassian-dc-mcp/common';
+import { simplifyBitbucketPRComments } from './pr-comment-mapper.js';
+import { simplifyBitbucketPRChanges } from './pr-changes-mapper.js';
 
 export class BitbucketService {
   constructor(host: string, token: string, fullBaseUrl?: string) {
@@ -99,7 +102,7 @@ export class BitbucketService {
   async getPullRequestCommentsAndActions(projectKey: string, repositorySlug: string, pullRequestId: string, start?: number,
     limit: number = 25
   ) {
-    return handleApiOperation(
+    const result = await handleApiOperation(
       () => PullRequestsService.getActivities(
         projectKey,
         pullRequestId,
@@ -110,7 +113,184 @@ export class BitbucketService {
         limit
       ),
       'Error fetching pull request comments'
-    )
+    );
+
+    // Apply simplification if the API call was successful
+    if (result.success && result.data) {
+      const simplifiedData = simplifyBitbucketPRComments(result.data);
+      return {
+        success: true,
+        data: simplifiedData
+      };
+    }
+
+    return result;
+  }
+
+  /**
+   * Get pull request changes
+   * @param projectKey The project key
+   * @param repositorySlug The repository slug
+   * @param pullRequestId The pull request ID
+   * @param sinceId Optional since commit hash to stream changes for a RANGE arbitrary change scope
+   * @param changeScope Optional scope: 'UNREVIEWED' for unreviewed changes, 'RANGE' for changes between commits, 'ALL' for all changes (default)
+   * @param untilId Optional until commit hash to stream changes for a RANGE arbitrary change scope
+   * @param withComments Optional flag to include comment counts (default: true)
+   * @param start Optional pagination start
+   * @param limit Optional pagination limit (default: 25)
+   * @returns Promise with PR changes data
+   */
+  async getPullRequestChanges(
+    projectKey: string,
+    repositorySlug: string,
+    pullRequestId: string,
+    sinceId?: string,
+    changeScope?: string,
+    untilId?: string,
+    withComments?: string,
+    start?: number,
+    limit: number = 25
+  ) {
+    const result = await handleApiOperation(
+      () => PullRequestsService.streamChanges1(
+        projectKey,
+        pullRequestId,
+        repositorySlug,
+        sinceId,
+        changeScope,
+        untilId,
+        withComments,
+        start,
+        limit
+      ),
+      'Error fetching pull request changes'
+    );
+
+    // Apply simplification if the API call was successful
+    if (result.success && result.data) {
+      const simplifiedData = simplifyBitbucketPRChanges(result.data);
+      return {
+        ...result,
+        data: simplifiedData
+      };
+    }
+
+    return result;
+  }
+
+  /**
+   * Post a comment to a pull request
+   * @param projectKey The project key
+   * @param repositorySlug The repository slug
+   * @param pullRequestId The pull request ID
+   * @param text The comment text
+   * @param parentId Optional parent comment ID for replies
+   * @param filePath Optional file path for file-specific comments
+   * @param line Optional line number for line-specific comments
+   * @param lineType Optional line type ('ADDED', 'REMOVED', 'CONTEXT') for line comments
+   * @returns Promise with created comment data
+   */
+  async postPullRequestComment(
+    projectKey: string,
+    repositorySlug: string,
+    pullRequestId: string,
+    text: string,
+    parentId?: number,
+    filePath?: string,
+    line?: number,
+    lineType?: 'ADDED' | 'REMOVED' | 'CONTEXT'
+  ) {
+    const comment: any = {
+      text
+    };
+
+    // Add parent reference for replies
+    if (parentId) {
+      comment.parent = { id: parentId };
+    }
+
+    // Add anchor for file/line comments
+    if (filePath) {
+      comment.anchor = {
+        path: filePath,
+        diffType: 'EFFECTIVE'
+      };
+
+      // Add line-specific anchor properties
+      if (line !== undefined && lineType) {
+        comment.anchor.line = line;
+        comment.anchor.lineType = lineType;
+        comment.anchor.fileType = 'TO'; // Default to destination file
+      }
+    }
+
+    return handleApiOperation(
+      () => PullRequestsService.createComment2(
+        projectKey,
+        pullRequestId,
+        repositorySlug,
+        comment
+      ),
+      'Error posting pull request comment'
+    );
+  }
+
+
+  /**
+   * Get text diff for a specific file in a pull request
+   * @param projectKey The project key
+   * @param repositorySlug The repository slug
+   * @param pullRequestId The pull request ID
+   * @param path The path to the file which should be diffed
+   * @param contextLines Optional number of context lines to include around added/removed lines
+   * @param sinceId Optional since commit hash to stream a diff between two arbitrary hashes
+   * @param srcPath Optional previous path to the file, if the file has been copied, moved or renamed
+   * @param diffType Optional type of diff being requested
+   * @param untilId Optional until commit hash to stream a diff between two arbitrary hashes
+   * @param whitespace Optional whitespace flag which can be set to 'ignore-all'
+   * @returns Promise with text diff data
+   */
+  async getPullRequestDiff(
+    projectKey: string,
+    repositorySlug: string,
+    pullRequestId: string,
+    path: string,
+    contextLines?: string,
+    sinceId?: string,
+    srcPath?: string,
+    diffType?: string,
+    untilId?: string,
+    whitespace?: string
+  ) {
+    return handleApiOperation(
+      () => __request(OpenAPI, {
+        method: 'GET',
+        url: '/api/latest/projects/{projectKey}/repos/{repositorySlug}/pull-requests/{pullRequestId}/diff/{path}',
+        path: {
+          'path': path,
+          'projectKey': projectKey,
+          'pullRequestId': pullRequestId,
+          'repositorySlug': repositorySlug,
+        },
+        query: {
+          'contextLines': contextLines,
+          'sinceId': sinceId,
+          'srcPath': srcPath,
+          'diffType': diffType,
+          'untilId': untilId,
+          'whitespace': whitespace,
+        },
+        headers: {
+          'Accept': 'text/plain'
+        },
+        errors: {
+          400: `If the request was malformed.`,
+          401: `The currently authenticated user has insufficient permissions to view the repository or pull request.`,
+          404: `The repository or pull request does not exist.`,
+        },
+      }),
+      'Error fetching pull request diff'
+    );
   }
 
   static validateConfig(): string[] {
@@ -160,5 +340,38 @@ export const bitbucketToolSchemas = {
     pullRequestId: z.string().describe("The pull request ID"),
     start: z.number().optional().describe("Start number for pagination"),
     limit: z.number().optional().default(25).describe("Number of items to return")
+  },
+  getPullRequestChanges: {
+    projectKey: z.string().describe("The project key"),
+    repositorySlug: z.string().describe("The repository slug"),
+    pullRequestId: z.string().describe("The pull request ID"),
+    sinceId: z.string().optional().describe("The since commit hash to stream changes for a RANGE arbitrary change scope"),
+    changeScope: z.string().optional().describe("UNREVIEWED for unreviewed changes, RANGE for changes between commits, ALL for all changes (default)"),
+    untilId: z.string().optional().describe("The until commit hash to stream changes for a RANGE arbitrary change scope"),
+    withComments: z.string().optional().describe("true to apply comment counts in the changes (default), false to stream changes without comment counts"),
+    start: z.number().optional().describe("Start number for pagination"),
+    limit: z.number().optional().default(25).describe("Number of items to return")
+  },
+  postPullRequestComment: {
+    projectKey: z.string().describe("The project key"),
+    repositorySlug: z.string().describe("The repository slug"),
+    pullRequestId: z.string().describe("The pull request ID"),
+    text: z.string().describe("The comment text"),
+    parentId: z.number().optional().describe("Parent comment ID for replies"),
+    filePath: z.string().optional().describe("File path for file-specific comments"),
+    line: z.number().optional().describe("Line number for line-specific comments"),
+    lineType: z.enum(['ADDED', 'REMOVED', 'CONTEXT']).optional().describe("Line type for line comments")
+  },
+  getPullRequestDiff: {
+    projectKey: z.string().describe("The project key"),
+    repositorySlug: z.string().describe("The repository slug"),
+    pullRequestId: z.string().describe("The pull request ID"),
+    path: z.string().describe("The path to the file which should be diffed. Note: Before getting diff, use getPullRequestChanges to understand what files were changed in the PR"),
+    contextLines: z.string().optional().describe("Number of context lines to include around added/removed lines in the diff"),
+    sinceId: z.string().optional().describe("The since commit hash to stream a diff between two arbitrary hashes"),
+    srcPath: z.string().optional().describe("The previous path to the file, if the file has been copied, moved or renamed"),
+    diffType: z.string().optional().describe("The type of diff being requested"),
+    untilId: z.string().optional().describe("The until commit hash to stream a diff between two arbitrary hashes"),
+    whitespace: z.string().optional().describe("Optional whitespace flag which can be set to 'ignore-all'")
   }
 };

package/src/index.ts

@@ -73,13 +73,44 @@ server.tool(
 );
 
 server.tool(
-  "bitbucket_getPullRequestCommentsAndAction",
+  "bitbucket_getPR_CommentsAndAction",
   "Get comments for a Bitbucket pull request and other actions, like approvals",
   bitbucketToolSchemas.getPullRequestComments,
   async ({ projectKey, repositorySlug, pullRequestId, start, limit }) => {
     const result = await bitbucketService.getPullRequestCommentsAndActions(projectKey, repositorySlug, pullRequestId, start, limit);
     return formatToolResponse(result);
   }
-)
+);
+
+server.tool(
+  "bitbucket_getPullRequestChanges",
+  "Get the changes for a Bitbucket pull request",
+  bitbucketToolSchemas.getPullRequestChanges,
+  async ({ projectKey, repositorySlug, pullRequestId, sinceId, changeScope, untilId, withComments, start, limit }) => {
+    const result = await bitbucketService.getPullRequestChanges(projectKey, repositorySlug, pullRequestId, sinceId, changeScope, untilId, withComments, start, limit);
+    return formatToolResponse(result);
+  }
+);
+
+server.tool(
+  "bitbucket_postPullRequestComment",
+  "Post a comment to a Bitbucket pull request",
+  bitbucketToolSchemas.postPullRequestComment,
+  async ({ projectKey, repositorySlug, pullRequestId, text, parentId, filePath, line, lineType }) => {
+    const result = await bitbucketService.postPullRequestComment(projectKey, repositorySlug, pullRequestId, text, parentId, filePath, line, lineType);
+    return formatToolResponse(result);
+  }
+);
+
+
+server.tool(
+  "bitbucket_getPullRequestDiff",
+  "Get text diff for a specific file in a Bitbucket pull request. Returns plain text diff format. Note: Before getting diff, use getPullRequestChanges to understand what files were changed in the PR",
+  bitbucketToolSchemas.getPullRequestDiff,
+  async ({ projectKey, repositorySlug, pullRequestId, path, contextLines, sinceId, srcPath, diffType, untilId, whitespace }) => {
+    const result = await bitbucketService.getPullRequestDiff(projectKey, repositorySlug, pullRequestId, path, contextLines, sinceId, srcPath, diffType, untilId, whitespace);
+    return formatToolResponse(result);
+  }
+);
 
 await connectServer(server);

package/src/pr-changes-mapper.ts

@@ -0,0 +1,216 @@
+// Original API response interfaces
+interface PathInfo {
+  components: string[];
+  parent: string;
+  name: string;
+  extension: string;
+  toString: string;
+}
+
+interface ChangeProperties {
+  gitChangeType: string;
+  orphanedComments?: number;
+  activeComments?: number;
+  changeScope?: string;
+}
+
+interface ChangeLinks {
+  self: (null | string)[];
+}
+
+interface PRChange {
+  contentId: string;
+  fromContentId: string;
+  path: PathInfo;
+  srcPath?: PathInfo;
+  percentUnchanged?: number;
+  type: string;
+  nodeType?: string;
+  executable?: boolean;
+  srcExecutable?: boolean;
+  links?: ChangeLinks;
+  properties: ChangeProperties;
+}
+
+interface PRChangesResponse {
+  fromHash: string;
+  toHash: string;
+  properties: {
+    changeScope: string;
+  };
+  values: PRChange[];
+  size: number;
+  isLastPage: boolean;
+  start: number;
+  limit: number;
+  nextPageStart: number | null;
+}
+
+// Simplified interfaces
+interface SimplifiedPath {
+  name: string;
+  path: string;
+  extension?: string;
+}
+
+interface SimplifiedChange {
+  contentId: string;
+  path: SimplifiedPath;
+  srcPath?: SimplifiedPath;
+  type: string;
+  gitChangeType: string;
+  comments?: number;
+}
+
+interface SimplifiedPRChangesResponse {
+  fromHash: string;
+  toHash: string;
+  changeScope: string;
+  changes: SimplifiedChange[];
+  summary: {
+    totalChanges: number;
+    additions: number;
+    deletions: number;
+    modifications: number;
+    moves: number;
+    filesWithComments: number;
+  };
+  isLastPage: boolean;
+}
+
+// Type guards
+function isPathInfo(obj: unknown): obj is PathInfo {
+  return (
+    typeof obj === 'object' &&
+    obj !== null &&
+    Array.isArray((obj as any).components) &&
+    typeof (obj as any).name === 'string' &&
+    typeof (obj as any).toString === 'string'
+  );
+}
+
+function isPRChange(obj: unknown): obj is PRChange {
+  return (
+    typeof obj === 'object' &&
+    obj !== null &&
+    typeof (obj as any).contentId === 'string' &&
+    typeof (obj as any).type === 'string' &&
+    isPathInfo((obj as any).path) &&
+    typeof (obj as any).properties === 'object' &&
+    typeof (obj as any).properties.gitChangeType === 'string'
+  );
+}
+
+function isPRChangesResponse(obj: unknown): obj is PRChangesResponse {
+  return (
+    typeof obj === 'object' &&
+    obj !== null &&
+    typeof (obj as any).fromHash === 'string' &&
+    typeof (obj as any).toHash === 'string' &&
+    Array.isArray((obj as any).values) &&
+    typeof (obj as any).isLastPage === 'boolean'
+  );
+}
+
+// Transformation functions
+function simplifyPath(path: PathInfo): SimplifiedPath {
+  return {
+    name: path.name,
+    path: path.toString,
+    ...(path.extension && { extension: path.extension })
+  };
+}
+
+function simplifyChange(change: PRChange): SimplifiedChange {
+  const result: SimplifiedChange = {
+    contentId: change.contentId,
+    path: simplifyPath(change.path),
+    type: change.type,
+    gitChangeType: change.properties.gitChangeType
+  };
+
+  // Add source path for moves/renames
+  if (change.srcPath) {
+    result.srcPath = simplifyPath(change.srcPath);
+  }
+
+  // Add comment count if present
+  const commentCount = (change.properties.orphanedComments || 0) + (change.properties.activeComments || 0);
+  if (commentCount > 0) {
+    result.comments = commentCount;
+  }
+
+  return result;
+}
+
+export function simplifyBitbucketPRChanges(response: any): SimplifiedPRChangesResponse | any {
+  // Validate response structure
+  if (!isPRChangesResponse(response)) {
+    return response;
+  }
+
+  const changes: SimplifiedChange[] = [];
+
+  // Process each change with type guard validation
+  for (const change of response.values || []) {
+    if (isPRChange(change)) {
+      changes.push(simplifyChange(change));
+    }
+  }
+
+  // If no valid changes were found, return the original response
+  if (changes.length === 0 && (response.values || []).length > 0) {
+    return response;
+  }
+
+  // Calculate summary statistics
+  const additions = changes.filter(c => c.type === 'ADD').length;
+  const deletions = changes.filter(c => c.type === 'DELETE').length;
+  const modifications = changes.filter(c => c.type === 'MODIFY').length;
+  const moves = changes.filter(c => c.type === 'MOVE').length;
+  const filesWithComments = changes.filter(c => c.comments && c.comments > 0).length;
+
+  return {
+    fromHash: response.fromHash,
+    toHash: response.toHash,
+    changeScope: response.properties.changeScope,
+    changes,
+    summary: {
+      totalChanges: changes.length,
+      additions,
+      deletions,
+      modifications,
+      moves,
+      filesWithComments
+    },
+    isLastPage: response.isLastPage
+  };
+}
+
+export function getChangesSummary(response: any): string[] {
+  const changeSummaries: string[] = [];
+
+  for (const change of response.values || []) {
+    if (isPRChange(change)) {
+      const action = change.type === 'ADD' ? 'Added' :
+                    change.type === 'DELETE' ? 'Deleted' :
+                    change.type === 'MODIFY' ? 'Modified' :
+                    change.type === 'MOVE' ? 'Moved' : change.type;
+
+      let summary = `${action}: ${change.path.toString}`;
+
+      if (change.srcPath && change.type === 'MOVE') {
+        summary += ` (from ${change.srcPath.toString})`;
+      }
+
+      const commentCount = (change.properties.orphanedComments || 0) + (change.properties.activeComments || 0);
+      if (commentCount > 0) {
+        summary += ` [${commentCount} comment${commentCount > 1 ? 's' : ''}]`;
+      }
+
+      changeSummaries.push(summary);
+    }
+  }
+
+  return changeSummaries;
+}