@atlassian-dc-mcp/bitbucket 0.12.2 → 0.14.0

package/src/__tests__/bitbucket-token-optimization.test.ts

@@ -0,0 +1,412 @@
+import { BitbucketService } from '../bitbucket-service.js';
+import { PullRequestsService } from '../bitbucket-client/index.js';
+
+jest.mock('../bitbucket-client/index.js', () => ({
+  PullRequestsService: {
+    getActivities: jest.fn(),
+    streamChanges1: jest.fn(),
+    createComment2: jest.fn(),
+    create: jest.fn(),
+    update: jest.fn(),
+  },
+  ProjectService: {},
+  RepositoryService: {},
+  OpenAPI: {
+    BASE: '',
+    TOKEN: '',
+    VERSION: '',
+  },
+}));
+
+function createUser(name: string, displayName: string) {
+  return {
+    name,
+    emailAddress: `${name}@example.com`,
+    active: true,
+    displayName,
+    id: 1,
+    slug: name,
+    type: 'NORMAL',
+    links: {
+      self: [{ href: `https://bitbucket.example.com/users/${name}` }],
+    },
+  };
+}
+
+function createComment(overrides: Record<string, unknown> = {}) {
+  return {
+    properties: { repositoryId: 1 },
+    id: 101,
+    version: 1,
+    text: 'Looks good',
+    author: createUser('reviewer', 'Reviewer'),
+    createdDate: 20,
+    updatedDate: 21,
+    comments: [],
+    anchor: {
+      fromHash: 'abc',
+      toHash: 'def',
+      line: 10,
+      lineType: 'ADDED',
+      fileType: 'TO',
+      path: 'src/app.ts',
+      diffType: 'EFFECTIVE',
+      orphaned: false,
+    },
+    threadResolved: false,
+    severity: 'NORMAL',
+    state: 'OPEN',
+    permittedOperations: {
+      editable: true,
+      transitionable: true,
+      deletable: true,
+    },
+    ...overrides,
+  };
+}
+
+describe('BitbucketService token optimization paths', () => {
+  let service: BitbucketService;
+
+  beforeEach(() => {
+    service = new BitbucketService('test-host', 'test-token');
+    jest.clearAllMocks();
+  });
+
+  describe('getPullRequestCommentsAndActions', () => {
+    const mockActivityResponse = {
+      isLastPage: false,
+      values: [
+        {
+          id: 1,
+          createdDate: 10,
+          user: createUser('author', 'Author'),
+          action: 'OPENED',
+        },
+        {
+          id: 2,
+          createdDate: 20,
+          user: createUser('reviewer', 'Reviewer'),
+          action: 'COMMENTED',
+          comment: createComment(),
+        },
+      ],
+    };
+
+    it('returns compact output by default', async () => {
+      (PullRequestsService.getActivities as jest.Mock).mockResolvedValue(mockActivityResponse);
+
+      const result = await service.getPullRequestCommentsAndActions('TEST', 'repo', '123');
+
+      expect(result.success).toBe(true);
+      expect(result.data).toEqual({
+        isLastPage: false,
+        activities: [
+          {
+            id: 1,
+            createdDate: 10,
+            user: { name: 'author', displayName: 'Author' },
+            action: 'OPENED',
+          },
+          {
+            id: 2,
+            createdDate: 20,
+            user: { name: 'reviewer', displayName: 'Reviewer' },
+            action: 'COMMENTED',
+            comment: {
+              id: 101,
+              text: 'Looks good',
+              author: { name: 'reviewer', displayName: 'Reviewer' },
+              createdDate: 20,
+              anchor: {
+                line: 10,
+                path: 'src/app.ts',
+                fileType: 'TO',
+              },
+              comments: [],
+              threadResolved: false,
+              state: 'OPEN',
+            },
+          },
+        ],
+        summary: {
+          totalActivities: 2,
+          prAuthor: { name: 'author', displayName: 'Author' },
+          commentCount: 1,
+          unresolvedCount: 1,
+        },
+      });
+      expect(PullRequestsService.getActivities).toHaveBeenCalledWith('TEST', '123', 'repo', undefined, undefined, undefined, 25);
+    });
+
+    it('skips resolved threads by default and includes them on request', async () => {
+      const resolvedActivityResponse = {
+        isLastPage: true,
+        values: [
+          {
+            id: 1,
+            createdDate: 10,
+            user: createUser('author', 'Author'),
+            action: 'OPENED',
+          },
+          {
+            id: 2,
+            createdDate: 20,
+            user: createUser('reviewer', 'Reviewer'),
+            action: 'COMMENTED',
+            comment: createComment({
+              id: 202,
+              text: 'Resolved comment',
+              threadResolved: true,
+              comments: [createComment({ id: 203, text: 'Resolved reply', anchor: undefined, threadResolved: true })],
+            }),
+          },
+        ],
+      };
+
+      (PullRequestsService.getActivities as jest.Mock).mockResolvedValue(resolvedActivityResponse);
+
+      const defaultResult = await service.getPullRequestCommentsAndActions('TEST', 'repo', '123');
+      const includeResolvedResult = await service.getPullRequestCommentsAndActions('TEST', 'repo', '123', undefined, undefined, 'compact', true);
+
+      expect(defaultResult.success).toBe(true);
+      expect(defaultResult.data).toEqual({
+        isLastPage: true,
+        activities: [
+          {
+            id: 1,
+            createdDate: 10,
+            user: { name: 'author', displayName: 'Author' },
+            action: 'OPENED',
+          },
+        ],
+        summary: {
+          totalActivities: 1,
+          prAuthor: { name: 'author', displayName: 'Author' },
+          commentCount: 0,
+          unresolvedCount: 0,
+        },
+      });
+      expect(includeResolvedResult.success).toBe(true);
+      expect(includeResolvedResult.data).toEqual({
+        isLastPage: true,
+        activities: [
+          {
+            id: 1,
+            createdDate: 10,
+            user: { name: 'author', displayName: 'Author' },
+            action: 'OPENED',
+          },
+          {
+            id: 2,
+            createdDate: 20,
+            user: { name: 'reviewer', displayName: 'Reviewer' },
+            action: 'COMMENTED',
+            comment: {
+              id: 202,
+              text: 'Resolved comment',
+              author: { name: 'reviewer', displayName: 'Reviewer' },
+              createdDate: 20,
+              anchor: {
+                line: 10,
+                path: 'src/app.ts',
+                fileType: 'TO',
+              },
+              comments: [
+                {
+                  id: 203,
+                  text: 'Resolved reply',
+                  author: { name: 'reviewer', displayName: 'Reviewer' },
+                  createdDate: 20,
+                  comments: [],
+                  threadResolved: true,
+                  state: 'OPEN',
+                },
+              ],
+              threadResolved: true,
+              state: 'OPEN',
+            },
+          },
+        ],
+        summary: {
+          totalActivities: 2,
+          prAuthor: { name: 'author', displayName: 'Author' },
+          commentCount: 1,
+          unresolvedCount: 0,
+        },
+      });
+    });
+
+    it('returns summary output when requested', async () => {
+      (PullRequestsService.getActivities as jest.Mock).mockResolvedValue(mockActivityResponse);
+
+      const result = await service.getPullRequestCommentsAndActions('TEST', 'repo', '123', 5, 10, 'summary');
+
+      expect(result.success).toBe(true);
+      expect(result.data).toEqual({
+        isLastPage: false,
+        summary: {
+          totalActivities: 2,
+          prAuthor: { name: 'author', displayName: 'Author' },
+          commentCount: 1,
+          unresolvedCount: 1,
+        },
+        items: ['Reviewer on src/app.ts:10: Looks good'],
+      });
+      expect(PullRequestsService.getActivities).toHaveBeenCalledWith('TEST', '123', 'repo', undefined, undefined, 5, 10);
+    });
+
+    it('returns the raw payload when output is full', async () => {
+      (PullRequestsService.getActivities as jest.Mock).mockResolvedValue(mockActivityResponse);
+
+      const result = await service.getPullRequestCommentsAndActions('TEST', 'repo', '123', undefined, undefined, 'full');
+
+      expect(result.success).toBe(true);
+      expect(result.data).toStrictEqual(mockActivityResponse);
+    });
+  });
+
+  describe('getPullRequestChanges', () => {
+    const mockChangesResponse = {
+      fromHash: 'abc',
+      toHash: 'def',
+      properties: { changeScope: 'ALL' },
+      values: [
+        {
+          contentId: 'content-1',
+          fromContentId: 'from-content-1',
+          path: {
+            components: ['src', 'app.ts'],
+            parent: 'src',
+            name: 'app.ts',
+            extension: 'ts',
+            toString: 'src/app.ts',
+          },
+          type: 'MODIFY',
+          properties: {
+            gitChangeType: 'MODIFY',
+            activeComments: 2,
+          },
+        },
+      ],
+      size: 1,
+      isLastPage: true,
+      start: 0,
+      limit: 25,
+      nextPageStart: null,
+    };
+
+    it('returns compact output by default', async () => {
+      (PullRequestsService.streamChanges1 as jest.Mock).mockResolvedValue(mockChangesResponse);
+
+      const result = await service.getPullRequestChanges('TEST', 'repo', '123');
+
+      expect(result.success).toBe(true);
+      expect(result.data).toEqual({
+        fromHash: 'abc',
+        toHash: 'def',
+        changeScope: 'ALL',
+        changes: [
+          {
+            contentId: 'content-1',
+            path: {
+              name: 'app.ts',
+              path: 'src/app.ts',
+              extension: 'ts',
+            },
+            type: 'MODIFY',
+            gitChangeType: 'MODIFY',
+            comments: 2,
+          },
+        ],
+        summary: {
+          totalChanges: 1,
+          additions: 0,
+          deletions: 0,
+          modifications: 1,
+          moves: 0,
+          filesWithComments: 1,
+        },
+        isLastPage: true,
+      });
+    });
+
+    it('returns summary output when requested', async () => {
+      (PullRequestsService.streamChanges1 as jest.Mock).mockResolvedValue(mockChangesResponse);
+
+      const result = await service.getPullRequestChanges('TEST', 'repo', '123', undefined, undefined, undefined, undefined, undefined, undefined, 'summary');
+
+      expect(result.success).toBe(true);
+      expect(result.data).toEqual({
+        fromHash: 'abc',
+        toHash: 'def',
+        changeScope: 'ALL',
+        isLastPage: true,
+        summary: {
+          totalChanges: 1,
+          additions: 0,
+          deletions: 0,
+          modifications: 1,
+          moves: 0,
+          filesWithComments: 1,
+        },
+        items: ['Modified: src/app.ts [2 comments]'],
+      });
+    });
+
+    it('returns the raw payload when output is full', async () => {
+      (PullRequestsService.streamChanges1 as jest.Mock).mockResolvedValue(mockChangesResponse);
+
+      const result = await service.getPullRequestChanges('TEST', 'repo', '123', undefined, undefined, undefined, undefined, undefined, undefined, 'full');
+
+      expect(result.success).toBe(true);
+      expect(result.data).toBe(mockChangesResponse);
+    });
+  });
+
+  describe('full mutation output', () => {
+    it('returns the raw comment response when requested', async () => {
+      const mockComment = {
+        id: 222,
+        text: 'Raw comment',
+        state: 'OPEN',
+      };
+      (PullRequestsService.createComment2 as jest.Mock).mockResolvedValue(mockComment);
+
+      const result = await service.postPullRequestComment('TEST', 'repo', '123', 'Raw comment', undefined, undefined, undefined, undefined, undefined, 'full');
+
+      expect(result.success).toBe(true);
+      expect(result.data).toBe(mockComment);
+    });
+
+    it('returns the raw PR create response when requested', async () => {
+      const mockPullRequest = {
+        id: 10,
+        version: 1,
+        title: 'Raw create',
+        state: 'OPEN',
+      };
+      (PullRequestsService.create as jest.Mock).mockResolvedValue(mockPullRequest);
+
+      const result = await service.createPullRequest('TEST', 'repo', 'Raw create', undefined, 'refs/heads/feature', 'refs/heads/main', undefined, 'full');
+
+      expect(result.success).toBe(true);
+      expect(result.data).toBe(mockPullRequest);
+    });
+
+    it('returns the raw PR update response when requested', async () => {
+      const mockPullRequest = {
+        id: 11,
+        version: 2,
+        title: 'Raw update',
+        state: 'OPEN',
+      };
+      (PullRequestsService.update as jest.Mock).mockResolvedValue(mockPullRequest);
+
+      const result = await service.updatePullRequest('TEST', 'repo', '123', 1, 'Raw update', undefined, undefined, 'full');
+
+      expect(result.success).toBe(true);
+      expect(result.data).toBe(mockPullRequest);
+    });
+  });
+});

package/src/__tests__/config.test.ts

@@ -0,0 +1,64 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+describe('Bitbucket config', () => {
+  const originalEnv = process.env;
+  const originalCwd = process.cwd();
+  let tempDir: string;
+
+  beforeEach(() => {
+    jest.resetModules();
+    process.env = { ...originalEnv };
+    delete process.env.ATLASSIAN_DC_MCP_CONFIG_FILE;
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'bitbucket-config-'));
+    process.chdir(tempDir);
+  });
+
+  afterEach(() => {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+    process.chdir(originalCwd);
+  });
+
+  afterAll(() => {
+    process.env = originalEnv;
+  });
+
+  it('uses the configured page size when the env var is a positive integer', async () => {
+    process.env.BITBUCKET_DEFAULT_PAGE_SIZE = '40';
+
+    const { getDefaultPageSize } = await import('../config.js');
+
+    expect(getDefaultPageSize()).toBe(40);
+  });
+
+  it('falls back to 25 when the env var is invalid', async () => {
+    process.env.BITBUCKET_DEFAULT_PAGE_SIZE = '-1';
+
+    const { getDefaultPageSize } = await import('../config.js');
+
+    expect(getDefaultPageSize()).toBe(25);
+  });
+
+  it('reads the page size from the shared config file', async () => {
+    const sharedConfigPath = path.join(tempDir, 'shared.env');
+    fs.writeFileSync(sharedConfigPath, 'BITBUCKET_HOST=file-host\nBITBUCKET_API_TOKEN=file-token\nBITBUCKET_DEFAULT_PAGE_SIZE=35\n');
+    process.env.ATLASSIAN_DC_MCP_CONFIG_FILE = sharedConfigPath;
+
+    const { getBitbucketRuntimeConfig, getDefaultPageSize } = await import('../config.js');
+
+    expect(getDefaultPageSize()).toBe(35);
+    expect(getBitbucketRuntimeConfig().token).toBe('file-token');
+  });
+
+  it('keeps env values higher priority than the shared config file', async () => {
+    const sharedConfigPath = path.join(tempDir, 'shared.env');
+    fs.writeFileSync(sharedConfigPath, 'BITBUCKET_HOST=file-host\nBITBUCKET_API_TOKEN=file-token\nBITBUCKET_DEFAULT_PAGE_SIZE=35\n');
+    process.env.ATLASSIAN_DC_MCP_CONFIG_FILE = sharedConfigPath;
+    process.env.BITBUCKET_DEFAULT_PAGE_SIZE = '45';
+
+    const { getDefaultPageSize } = await import('../config.js');
+
+    expect(getDefaultPageSize()).toBe(45);
+  });
+});

package/src/__tests__/pr-comment-mapper.test.ts

@@ -1,4 +1,5 @@
 import {
+  filterPullRequestComments,
   simplifyBitbucketPRComments,
   getCommentSummary,
   type BitbucketPRApiResponse,
@@ -106,6 +107,7 @@ describe('PR Comment Mapper', () => {
     ],
     start: 0
   };
+  const [baseCommentActivity, openedActivity] = validPRResponse.values ?? [];
 
   describe('simplifyBitbucketPRComments', () => {
     it('should simplify valid PR response correctly', () => {
@@ -227,6 +229,143 @@ describe('PR Comment Mapper', () => {
       ]);
     });
 
+    it('should exclude resolved threads and all replies by default', () => {
+      const resolvedThreadResponse: BitbucketPRApiResponse = {
+        ...validPRResponse,
+        values: [
+          openedActivity!,
+          {
+            id: 1003,
+            createdDate: 1600000002000,
+            user: createUser('reviewer3', 105, 'Reviewer Three'),
+            action: 'COMMENTED',
+            commentAction: 'ADDED',
+            comment: createComment({
+              id: 2004,
+              text: 'Resolved thread root',
+              threadResolved: true,
+              comments: [
+                createComment({
+                  id: 2005,
+                  text: 'Resolved reply',
+                  anchor: undefined,
+                  threadResolved: true,
+                })
+              ]
+            })
+          },
+          baseCommentActivity!,
+        ],
+      };
+
+      const result = simplifyBitbucketPRComments(resolvedThreadResponse) as SimplifiedPRResponse;
+
+      expect(result.activities).toEqual([
+        {
+          id: 1002,
+          createdDate: 1600000001000,
+          user: {
+            name: 'testuser2',
+            displayName: 'User B'
+          },
+          action: 'OPENED'
+        },
+        {
+          id: 1001,
+          createdDate: 1600000000000,
+          user: {
+            name: 'testuser1',
+            displayName: 'User A'
+          },
+          action: 'COMMENTED',
+          commentAction: 'ADDED',
+          comment: {
+            id: 2001,
+            text: 'This needs review',
+            author: {
+              name: 'testuser1',
+              displayName: 'User A'
+            },
+            createdDate: 1600000000000,
+            anchor: {
+              line: 6,
+              path: 'config.yml',
+              fileType: 'TO'
+            },
+            comments: [],
+            threadResolved: false,
+            state: 'OPEN'
+          }
+        }
+      ]);
+      expect(result.summary.commentCount).toBe(1);
+      expect(getCommentSummary(resolvedThreadResponse)).toEqual(['User A on config.yml:6: This needs review']);
+    });
+
+    it('should include resolved threads when requested', () => {
+      const resolvedThreadResponse: BitbucketPRApiResponse = {
+        ...validPRResponse,
+        values: [
+          {
+            id: 1003,
+            createdDate: 1600000002000,
+            user: createUser('reviewer3', 105, 'Reviewer Three'),
+            action: 'COMMENTED',
+            commentAction: 'ADDED',
+            comment: createComment({
+              id: 2004,
+              text: 'Resolved thread root',
+              threadResolved: true,
+              comments: [
+                createComment({
+                  id: 2005,
+                  text: 'Resolved reply',
+                  anchor: undefined,
+                  threadResolved: true,
+                })
+              ]
+            })
+          }
+        ],
+      };
+
+      const result = simplifyBitbucketPRComments(resolvedThreadResponse, { includeResolved: true }) as SimplifiedPRResponse;
+
+      expect(result.activities[0].comment).toEqual({
+        id: 2004,
+        text: 'Resolved thread root',
+        author: {
+          name: 'testuser1',
+          displayName: 'User A'
+        },
+        createdDate: 1600000000000,
+        anchor: {
+          line: 6,
+          path: 'config.yml',
+          fileType: 'TO'
+        },
+        comments: [
+          {
+            id: 2005,
+            text: 'Resolved reply',
+            author: {
+              name: 'testuser1',
+              displayName: 'User A'
+            },
+            createdDate: 1600000000000,
+            comments: [],
+            threadResolved: true,
+            state: 'OPEN'
+          }
+        ],
+        threadResolved: true,
+        state: 'OPEN'
+      });
+      expect(getCommentSummary(resolvedThreadResponse, { includeResolved: true })).toEqual([
+        'User A on config.yml:6: Resolved thread root'
+      ]);
+    });
+
     it('should skip malformed nested replies', () => {
       const malformedNestedResponse: BitbucketPRApiResponse = {
         ...validPRResponse,
@@ -396,4 +535,25 @@ describe('PR Comment Mapper', () => {
       expect(summary).toHaveLength(0);
     });
   });
+
+  describe('filterPullRequestComments', () => {
+    it('should keep non-comment activities while removing resolved comment activities by default', () => {
+      const response: BitbucketPRApiResponse = {
+        ...validPRResponse,
+        values: [
+          openedActivity!,
+          {
+            id: 1004,
+            createdDate: 1600000003000,
+            user: createUser('reviewer4', 106, 'Reviewer Four'),
+            action: 'COMMENTED',
+            commentAction: 'ADDED',
+            comment: createComment({ id: 2006, threadResolved: true })
+          }
+        ]
+      };
+
+      expect(filterPullRequestComments(response).values).toEqual([openedActivity!]);
+    });
+  });
 });