Merge pull request #14 from arseniilozytskyi/claude/jira-status-transitions-QP62l

Add support for JIRA status transitions

Author: b1ff

package-lock.json

@@ -0,0 +1,23 @@
+export default {
+  preset: 'ts-jest/presets/default-esm',
+  extensionsToTreatAsEsm: ['.ts'],
+  moduleNameMapper: {
+    '^(\\.{1,2}/.*)\\.js$': '$1',
+    '^@atlassian-dc-mcp/common$': '<rootDir>/../common/src/index.ts',
+  },
+  transform: {
+    '^.+\\.ts$': ['ts-jest', {
+      useESM: true,
+    }],
+  },
+  transformIgnorePatterns: [
+    'node_modules/(?!(@atlassian-dc-mcp)/)',
+  ],
+  testEnvironment: 'node',
+  testMatch: ['**/__tests__/**/*.test.ts'],
+  collectCoverageFrom: [
+    'src/**/*.ts',
+    '!src/**/*.d.ts',
+    '!src/**/index.ts',
+  ],
+};

packages/jira/jest.config.js

@@ -0,0 +1,236 @@
+import { JiraService } from '../jira-service.js';
+import { IssueService } from '../jira-client/index.js';
+
+jest.mock('../jira-client/index.js', () => ({
+  IssueService: {
+    getTransitions: jest.fn(),
+    doTransition: jest.fn(),
+    getIssue: jest.fn(),
+    editIssue: jest.fn(),
+    createIssue: jest.fn(),
+    getComments: jest.fn(),
+    addComment: jest.fn(),
+  },
+  SearchService: {
+    searchUsingSearchRequest: jest.fn(),
+  },
+  OpenAPI: {
+    BASE: '',
+    TOKEN: '',
+    VERSION: '',
+  },
+}));
+
+describe('JiraService', () => {
+  let jiraService: JiraService;
+  const mockIssueKey = 'PROJ-123';
+
+  beforeEach(() => {
+    jiraService = new JiraService('test-host', 'test-token');
+    jest.clearAllMocks();
+  });
+
+  describe('getTransitions', () => {
+    it('should successfully get available transitions for an issue', async () => {
+      const mockTransitionsData = {
+        transitions: [
+          {
+            id: '21',
+            name: 'Start Progress',
+            to: {
+              id: '3',
+              name: 'In Progress',
+              statusCategory: { name: 'In Progress' },
+            },
+          },
+          {
+            id: '31',
+            name: 'Done',
+            to: {
+              id: '4',
+              name: 'Done',
+              statusCategory: { name: 'Done' },
+            },
+          },
+        ],
+      };
+      (IssueService.getTransitions as jest.Mock).mockResolvedValue(mockTransitionsData);
+
+      const result = await jiraService.getTransitions(mockIssueKey);
+
+      expect(result.success).toBe(true);
+      expect(result.data).toBe(mockTransitionsData);
+      expect(IssueService.getTransitions).toHaveBeenCalledWith(mockIssueKey);
+    });
+
+    it('should return empty transitions array when no transitions available', async () => {
+      const mockTransitionsData = {
+        transitions: [],
+      };
+      (IssueService.getTransitions as jest.Mock).mockResolvedValue(mockTransitionsData);
+
+      const result = await jiraService.getTransitions(mockIssueKey);
+
+      expect(result.success).toBe(true);
+      expect(result.data).toBe(mockTransitionsData);
+      expect(result.data?.transitions).toHaveLength(0);
+    });
+
+    it('should handle API errors gracefully', async () => {
+      const mockError = new Error('Issue not found');
+      (IssueService.getTransitions as jest.Mock).mockRejectedValue(mockError);
+
+      const result = await jiraService.getTransitions(mockIssueKey);
+
+      expect(result.success).toBe(false);
+      expect(result.error).toBe('Issue not found');
+    });
+
+    it('should handle permission errors', async () => {
+      const mockError = new Error('Insufficient permissions to view transitions');
+      (IssueService.getTransitions as jest.Mock).mockRejectedValue(mockError);
+
+      const result = await jiraService.getTransitions('RESTRICTED-1');
+
+      expect(result.success).toBe(false);
+      expect(result.error).toBe('Insufficient permissions to view transitions');
+    });
+  });
+
+  describe('transitionIssue', () => {
+    it('should successfully transition an issue to a new status', async () => {
+      (IssueService.doTransition as jest.Mock).mockResolvedValue(undefined);
+
+      const result = await jiraService.transitionIssue({
+        issueKey: mockIssueKey,
+        transitionId: '21',
+      });
+
+      expect(result.success).toBe(true);
+      expect(IssueService.doTransition).toHaveBeenCalledWith(mockIssueKey, {
+        transition: { id: '21' },
+      });
+    });
+
+    it('should successfully transition with additional fields', async () => {
+      (IssueService.doTransition as jest.Mock).mockResolvedValue(undefined);
+
+      const result = await jiraService.transitionIssue({
+        issueKey: mockIssueKey,
+        transitionId: '31',
+        fields: {
+          resolution: { name: 'Done' },
+          comment: { body: 'Closing this issue' },
+        },
+      });
+
+      expect(result.success).toBe(true);
+      expect(IssueService.doTransition).toHaveBeenCalledWith(mockIssueKey, {
+        transition: { id: '31' },
+        fields: {
+          resolution: { name: 'Done' },
+          comment: { body: 'Closing this issue' },
+        },
+      });
+    });
+
+    it('should handle invalid transition ID errors', async () => {
+      const mockError = new Error('Invalid transition ID');
+      (IssueService.doTransition as jest.Mock).mockRejectedValue(mockError);
+
+      const result = await jiraService.transitionIssue({
+        issueKey: mockIssueKey,
+        transitionId: '999',
+      });
+
+      expect(result.success).toBe(false);
+      expect(result.error).toBe('Invalid transition ID');
+    });
+
+    it('should handle missing required fields errors', async () => {
+      const mockError = new Error('Resolution field is required');
+      (IssueService.doTransition as jest.Mock).mockRejectedValue(mockError);
+
+      const result = await jiraService.transitionIssue({
+        issueKey: mockIssueKey,
+        transitionId: '31',
+      });
+
+      expect(result.success).toBe(false);
+      expect(result.error).toBe('Resolution field is required');
+    });
+
+    it('should handle permission errors', async () => {
+      const mockError = new Error('User does not have permission to transition this issue');
+      (IssueService.doTransition as jest.Mock).mockRejectedValue(mockError);
+
+      const result = await jiraService.transitionIssue({
+        issueKey: 'RESTRICTED-1',
+        transitionId: '21',
+      });
+
+      expect(result.success).toBe(false);
+      expect(result.error).toBe('User does not have permission to transition this issue');
+    });
+
+    it('should handle issue not found errors', async () => {
+      const mockError = new Error('Issue does not exist');
+      (IssueService.doTransition as jest.Mock).mockRejectedValue(mockError);
+
+      const result = await jiraService.transitionIssue({
+        issueKey: 'NONEXISTENT-999',
+        transitionId: '21',
+      });
+
+      expect(result.success).toBe(false);
+      expect(result.error).toBe('Issue does not exist');
+    });
+  });
+
+  describe('validateConfig', () => {
+    const originalEnv = process.env;
+
+    beforeEach(() => {
+      jest.resetModules();
+      process.env = { ...originalEnv };
+    });
+
+    afterAll(() => {
+      process.env = originalEnv;
+    });
+
+    it('should return empty array when all required env vars are present', () => {
+      process.env.JIRA_API_TOKEN = 'test-token';
+      process.env.JIRA_HOST = 'test-host';
+
+      const missingVars = JiraService.validateConfig();
+      expect(missingVars).toEqual([]);
+    });
+
+    it('should return missing vars when JIRA_API_TOKEN is missing', () => {
+      delete process.env.JIRA_API_TOKEN;
+      process.env.JIRA_HOST = 'test-host';
+
+      const missingVars = JiraService.validateConfig();
+      expect(missingVars).toContain('JIRA_API_TOKEN');
+    });
+
+    it('should return missing vars when both host options are missing', () => {
+      process.env.JIRA_API_TOKEN = 'test-token';
+      delete process.env.JIRA_HOST;
+      delete process.env.JIRA_API_BASE_PATH;
+
+      const missingVars = JiraService.validateConfig();
+      expect(missingVars).toContain('JIRA_HOST or JIRA_API_BASE_PATH');
+    });
+
+    it('should accept JIRA_API_BASE_PATH as alternative to JIRA_HOST', () => {
+      process.env.JIRA_API_TOKEN = 'test-token';
+      delete process.env.JIRA_HOST;
+      process.env.JIRA_API_BASE_PATH = 'https://test-host/rest';
+
+      const missingVars = JiraService.validateConfig();
+      expect(missingVars).toEqual([]);
+    });
+  });
+});

packages/jira/src/__tests__/jira-service.test.ts

@@ -79,4 +79,24 @@ server.tool(
   }
 )
 
+server.tool(
+  "jira_getTransitions",
+  `Get available status transitions for a JIRA issue in the ${jiraInstanceType}. Returns a list of transitions with their IDs, names, and target statuses.`,
+  jiraToolSchemas.getTransitions,
+  async ({ issueKey }) => {
+    const result = await jiraService.getTransitions(issueKey);
+    return formatToolResponse(result);
+  }
+);
+
+server.tool(
+  "jira_transitionIssue",
+  `Transition a JIRA issue to a new status in the ${jiraInstanceType}. Use jira_getTransitions first to get available transition IDs.`,
+  jiraToolSchemas.transitionIssue,
+  async (params) => {
+    const result = await jiraService.transitionIssue(params);
+    return formatToolResponse(result);
+  }
+);
+
 await connectServer(server);

packages/jira/src/index.ts

@@ -82,6 +82,29 @@ export class JiraService {
     }, 'Error updating issue');
   }
 
+  async getTransitions(issueKey: string) {
+    return handleApiOperation(
+      () => IssueService.getTransitions(issueKey),
+      'Error getting transitions'
+    );
+  }
+
+  async transitionIssue(params: {
+    issueKey: string;
+    transitionId: string;
+    fields?: Record<string, any>;
+  }) {
+    return handleApiOperation(async () => {
+      const requestBody: { transition: { id: string }; fields?: Record<string, any> } = {
+        transition: { id: params.transitionId }
+      };
+      if (params.fields) {
+        requestBody.fields = params.fields;
+      }
+      return IssueService.doTransition(params.issueKey, requestBody);
+    }, 'Error transitioning issue');
+  }
+
   static validateConfig(): string[] {
     const requiredEnvVars = ['JIRA_API_TOKEN'] as const;
     const missingVars: string[] = requiredEnvVars.filter(varName => !process.env[varName]);
@@ -125,5 +148,13 @@ export const jiraToolSchemas = {
     description: z.string().optional().describe("New description in JIRA Wiki Markup (optional)"),
     issueTypeId: z.string().optional().describe("New issue type id (optional)"),
     customFields: z.record(z.any()).optional().describe("Optional custom fields to update as key-value pairs. Examples: {'customfield_10001': 'Custom Value', 'priority': {'id': '1'}, 'assignee': {'name': 'john.doe'}, 'labels': ['urgent', 'bug']}")
+  },
+  getTransitions: {
+    issueKey: z.string().describe("JIRA issue key (e.g., PROJ-123)")
+  },
+  transitionIssue: {
+    issueKey: z.string().describe("JIRA issue key (e.g., PROJ-123)"),
+    transitionId: z.string().describe("The ID of the transition to perform. Use jira_getTransitions to find available transitions and their IDs."),
+    fields: z.record(z.any()).optional().describe("Optional fields required by the transition screen. Use jira_getTransitions to see which fields are available for each transition.")
   }
 };