@hubblecommerce/overmind-core 0.1.4 → 0.1.6

package/dist/src/integrations/confluence/confluence.client.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=confluence.client.test.d.ts.map

package/dist/src/integrations/confluence/confluence.client.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"confluence.client.test.d.ts","sourceRoot":"","sources":["../../../../src/integrations/confluence/confluence.client.test.ts"],"names":[],"mappings":""}

package/dist/src/integrations/confluence/confluence.client.test.js

@@ -0,0 +1,320 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { ConfluenceClient } from './confluence.client.js';
+const BASE_URL = 'https://example.atlassian.net';
+function makeClient() {
+    return new ConfluenceClient({
+        baseUrl: BASE_URL,
+        email: 'test@test.com',
+        apiToken: 'token',
+        rateLimit: 10000, // effectively no rate-limit delay in tests
+    });
+}
+function jsonResponse(data, status = 200) {
+    return new Response(JSON.stringify(data), {
+        status,
+        headers: { 'Content-Type': 'application/json' },
+    });
+}
+const spaceFixture = {
+    id: 'space-id-1',
+    key: 'TEST',
+    name: 'Test Space',
+    type: 'global',
+    status: 'current',
+    authorId: 'author1',
+    createdAt: '2024-01-01T00:00:00.000Z',
+    _links: { webui: '/spaces/TEST' },
+};
+const spaceResponse = { results: [spaceFixture], _links: {} };
+function makePageFixture(id) {
+    return {
+        id,
+        status: 'current',
+        title: `Page ${id}`,
+        spaceId: spaceFixture.id,
+        authorId: 'author1',
+        createdAt: '2024-01-01T00:00:00.000Z',
+        version: { createdAt: '2024-01-01T00:00:00.000Z', message: '', number: 1, minorEdit: false, authorId: 'author1' },
+        _links: { webui: `/wiki/spaces/TEST/pages/${id}` },
+    };
+}
+describe('ConfluenceClient', () => {
+    let fetchMock;
+    beforeEach(() => {
+        fetchMock = vi.fn();
+        vi.stubGlobal('fetch', fetchMock);
+        vi.useFakeTimers();
+    });
+    afterEach(() => {
+        vi.unstubAllGlobals();
+        vi.useRealTimers();
+    });
+    describe('getSpacePages', () => {
+        it('returns pages for a single-page response (no pagination)', async () => {
+            const pageResponse = { results: [makePageFixture('p1')], _links: {} };
+            fetchMock
+                .mockResolvedValueOnce(jsonResponse(spaceResponse))
+                .mockResolvedValueOnce(jsonResponse(pageResponse));
+            const promise = makeClient().getSpacePages('TEST');
+            await vi.runAllTimersAsync();
+            const pages = await promise;
+            expect(pages).toHaveLength(1);
+            expect(pages[0].id).toBe('p1');
+        });
+        it('follows pagination and combines results from multiple pages', async () => {
+            const page1Response = {
+                results: [makePageFixture('p1')],
+                _links: { next: `${BASE_URL}/wiki/api/v2/spaces/space-id-1/pages?cursor=abc` },
+            };
+            const page2Response = {
+                results: [makePageFixture('p2')],
+                _links: {},
+            };
+            fetchMock
+                .mockResolvedValueOnce(jsonResponse(spaceResponse))
+                .mockResolvedValueOnce(jsonResponse(page1Response))
+                .mockResolvedValueOnce(jsonResponse(page2Response));
+            const promise = makeClient().getSpacePages('TEST');
+            await vi.runAllTimersAsync();
+            const pages = await promise;
+            expect(pages).toHaveLength(2);
+            expect(pages[0].id).toBe('p1');
+            expect(pages[1].id).toBe('p2');
+        });
+        it('throws when space key is not found', async () => {
+            fetchMock.mockResolvedValueOnce(jsonResponse({ results: [], _links: {} }));
+            const promise = makeClient().getSpacePages('UNKNOWN');
+            const assertion = expect(promise).rejects.toThrow('Space with key "UNKNOWN" not found');
+            await vi.runAllTimersAsync();
+            await assertion;
+        });
+    });
+    describe('getPageLabels', () => {
+        it('returns label names from the response', async () => {
+            const labelResponse = {
+                results: [
+                    { id: '1', name: 'project-info', prefix: 'global' },
+                    { id: '2', name: 'active', prefix: 'global' },
+                ],
+                start: 0, limit: 200, size: 2, _links: {},
+            };
+            fetchMock.mockResolvedValueOnce(jsonResponse(labelResponse));
+            const promise = makeClient().getPageLabels('page1');
+            await vi.runAllTimersAsync();
+            const labels = await promise;
+            expect(labels).toEqual(['project-info', 'active']);
+        });
+        it('returns empty array when page has no labels', async () => {
+            const labelResponse = { results: [], start: 0, limit: 200, size: 0, _links: {} };
+            fetchMock.mockResolvedValueOnce(jsonResponse(labelResponse));
+            const promise = makeClient().getPageLabels('page1');
+            await vi.runAllTimersAsync();
+            const labels = await promise;
+            expect(labels).toEqual([]);
+        });
+    });
+    describe('createPageWithADF', () => {
+        const createPageResponse = {
+            id: 'new-page-1',
+            status: 'current',
+            title: 'My New Page',
+            spaceId: spaceFixture.id,
+            authorId: 'author1',
+            createdAt: '2024-01-01T00:00:00.000Z',
+            version: { createdAt: '2024-01-01T00:00:00.000Z', message: '', number: 1, minorEdit: false, authorId: 'author1' },
+            _links: { webui: '/wiki/spaces/TEST/pages/new-page-1' },
+        };
+        it('sends correct body structure with ADF content', async () => {
+            fetchMock.mockResolvedValueOnce(jsonResponse(createPageResponse));
+            const adfBody = { type: 'doc', version: 1, content: [] };
+            const promise = makeClient().createPageWithADF({ spaceId: 'S1', title: 'My New Page', adfBody });
+            await vi.runAllTimersAsync();
+            await promise;
+            const [, options] = fetchMock.mock.calls[0];
+            const body = JSON.parse(options.body);
+            expect(body.title).toBe('My New Page');
+            expect(body.spaceId).toBe('S1');
+            expect(body.body.representation).toBe('atlas_doc_format');
+            expect(JSON.parse(body.body.value)).toEqual(adfBody);
+        });
+        it('includes parentId in payload when provided', async () => {
+            fetchMock.mockResolvedValueOnce(jsonResponse(createPageResponse));
+            const promise = makeClient().createPageWithADF({ spaceId: 'S1', title: 'Child', adfBody: {}, parentId: 'parent-1' });
+            await vi.runAllTimersAsync();
+            await promise;
+            const [, options] = fetchMock.mock.calls[0];
+            const body = JSON.parse(options.body);
+            expect(body.parentId).toBe('parent-1');
+        });
+        it('omits parentId from payload when not provided', async () => {
+            fetchMock.mockResolvedValueOnce(jsonResponse(createPageResponse));
+            const promise = makeClient().createPageWithADF({ spaceId: 'S1', title: 'Root Page', adfBody: {} });
+            await vi.runAllTimersAsync();
+            await promise;
+            const [, options] = fetchMock.mock.calls[0];
+            const body = JSON.parse(options.body);
+            expect(body.parentId).toBeUndefined();
+        });
+        it('returns the created page', async () => {
+            fetchMock.mockResolvedValueOnce(jsonResponse(createPageResponse));
+            const promise = makeClient().createPageWithADF({ spaceId: 'S1', title: 'My New Page', adfBody: {} });
+            await vi.runAllTimersAsync();
+            const page = await promise;
+            expect(page.id).toBe('new-page-1');
+            expect(page.title).toBe('My New Page');
+        });
+    });
+    describe('getSpaces', () => {
+        it('returns spaces from paginated response', async () => {
+            fetchMock.mockResolvedValueOnce(jsonResponse({ results: [spaceFixture], _links: {} }));
+            const promise = makeClient().getSpaces();
+            await vi.runAllTimersAsync();
+            const spaces = await promise;
+            expect(spaces).toHaveLength(1);
+            expect(spaces[0].key).toBe('TEST');
+        });
+    });
+    describe('getPageById', () => {
+        it('returns the page for a given id', async () => {
+            const page = makePageFixture('p42');
+            fetchMock.mockResolvedValueOnce(jsonResponse(page));
+            const promise = makeClient().getPageById('p42');
+            await vi.runAllTimersAsync();
+            const result = await promise;
+            expect(result.id).toBe('p42');
+        });
+        it('uses default body format storage', async () => {
+            fetchMock.mockResolvedValueOnce(jsonResponse(makePageFixture('p1')));
+            const promise = makeClient().getPageById('p1');
+            await vi.runAllTimersAsync();
+            await promise;
+            const [url] = fetchMock.mock.calls[0];
+            expect(url).toContain('body-format=storage');
+        });
+        it('accepts atlas_doc_format body format', async () => {
+            fetchMock.mockResolvedValueOnce(jsonResponse(makePageFixture('p1')));
+            const promise = makeClient().getPageById('p1', 'atlas_doc_format');
+            await vi.runAllTimersAsync();
+            await promise;
+            const [url] = fetchMock.mock.calls[0];
+            expect(url).toContain('body-format=atlas_doc_format');
+        });
+    });
+    describe('getPageContent', () => {
+        it('returns body storage value', async () => {
+            const page = { ...makePageFixture('p1'), body: { storage: { value: '<p>Hello</p>' } } };
+            fetchMock.mockResolvedValueOnce(jsonResponse(page));
+            const promise = makeClient().getPageContent('p1');
+            await vi.runAllTimersAsync();
+            const content = await promise;
+            expect(content).toBe('<p>Hello</p>');
+        });
+        it('throws when page has no body', async () => {
+            const page = makePageFixture('p1'); // no body field
+            fetchMock.mockResolvedValueOnce(jsonResponse(page));
+            const promise = makeClient().getPageContent('p1');
+            const assertion = expect(promise).rejects.toThrow('no content');
+            await vi.runAllTimersAsync();
+            await assertion;
+        });
+    });
+    describe('getChildPages', () => {
+        it('returns child pages in a single request when below limit', async () => {
+            const results = [{ id: 'c1' }, { id: 'c2' }];
+            fetchMock.mockResolvedValueOnce(jsonResponse({ results, size: 2 }));
+            const promise = makeClient().getChildPages('parent1');
+            await vi.runAllTimersAsync();
+            const pages = await promise;
+            expect(pages).toHaveLength(2);
+            expect(fetchMock).toHaveBeenCalledTimes(1);
+        });
+        it('paginates when first response returns exactly the limit', async () => {
+            const fullPage = Array.from({ length: 250 }, (_, i) => ({ id: `c${i}` }));
+            fetchMock
+                .mockResolvedValueOnce(jsonResponse({ results: fullPage, size: 250 }))
+                .mockResolvedValueOnce(jsonResponse({ results: [{ id: 'c250' }], size: 1 }));
+            const promise = makeClient().getChildPages('parent1');
+            await vi.runAllTimersAsync();
+            const pages = await promise;
+            expect(pages).toHaveLength(251);
+            expect(fetchMock).toHaveBeenCalledTimes(2);
+            const [secondUrl] = fetchMock.mock.calls[1];
+            expect(secondUrl).toContain('start=250');
+        });
+    });
+    describe('getRecentPages', () => {
+        it('returns pages without space filter when no spaceKeys provided', async () => {
+            const pageResponse = { results: [makePageFixture('p1')] };
+            fetchMock.mockResolvedValueOnce(jsonResponse(pageResponse));
+            const promise = makeClient().getRecentPages();
+            await vi.runAllTimersAsync();
+            const pages = await promise;
+            expect(pages).toHaveLength(1);
+            const [url] = fetchMock.mock.calls[0];
+            expect(url).not.toContain('space-key');
+        });
+        it('adds space-key filter when spaceKeys provided', async () => {
+            const pageResponse = { results: [makePageFixture('p1')] };
+            fetchMock.mockResolvedValueOnce(jsonResponse(pageResponse));
+            const promise = makeClient().getRecentPages(['TEST', 'PROJ']);
+            await vi.runAllTimersAsync();
+            await promise;
+            const [url] = fetchMock.mock.calls[0];
+            expect(url).toContain('space-key=TEST');
+            expect(url).toContain('space-key=PROJ');
+        });
+        it('respects custom limit', async () => {
+            fetchMock.mockResolvedValueOnce(jsonResponse({ results: [] }));
+            const promise = makeClient().getRecentPages(undefined, 50);
+            await vi.runAllTimersAsync();
+            await promise;
+            const [url] = fetchMock.mock.calls[0];
+            expect(url).toContain('limit=50');
+        });
+    });
+    describe('getPageLabels pagination', () => {
+        it('fetches next page when first response fills the limit', async () => {
+            const fullPage = Array.from({ length: 200 }, (_, i) => ({ id: `${i}`, name: `label-${i}`, prefix: 'global' }));
+            const secondPage = { results: [{ id: '200', name: 'extra', prefix: 'global' }], start: 200, limit: 200, size: 1, _links: {} };
+            fetchMock
+                .mockResolvedValueOnce(jsonResponse({ results: fullPage, start: 0, limit: 200, size: 200, _links: {} }))
+                .mockResolvedValueOnce(jsonResponse(secondPage));
+            const promise = makeClient().getPageLabels('page1');
+            await vi.runAllTimersAsync();
+            const labels = await promise;
+            expect(labels).toHaveLength(201);
+            expect(labels[200]).toBe('extra');
+        });
+    });
+    describe('error handling', () => {
+        it('throws on 4xx error without retrying', async () => {
+            fetchMock.mockResolvedValue(new Response('Not Found', { status: 404, statusText: 'Not Found' }));
+            const promise = makeClient().getPageById('page1');
+            const assertion = expect(promise).rejects.toThrow();
+            await vi.runAllTimersAsync();
+            await assertion;
+            // Only 1 fetch call (no retries for 4xx)
+            expect(fetchMock).toHaveBeenCalledTimes(1);
+        });
+        it('retries on 5xx error and eventually throws', async () => {
+            fetchMock.mockResolvedValue(new Response('Server Error', { status: 500, statusText: 'Internal Server Error' }));
+            const promise = makeClient().getPageById('page1');
+            const assertion = expect(promise).rejects.toThrow();
+            await vi.runAllTimersAsync();
+            await assertion;
+            // 3 attempts total (initial + 2 retries)
+            expect(fetchMock).toHaveBeenCalledTimes(3);
+        });
+        it('succeeds on retry after transient 5xx', async () => {
+            const page = makePageFixture('p1');
+            fetchMock
+                .mockResolvedValueOnce(new Response('Server Error', { status: 500, statusText: 'Internal Server Error' }))
+                .mockResolvedValueOnce(jsonResponse(page));
+            const promise = makeClient().getPageById('p1');
+            await vi.runAllTimersAsync();
+            const result = await promise;
+            expect(result.id).toBe('p1');
+            expect(fetchMock).toHaveBeenCalledTimes(2);
+        });
+    });
+});

package/dist/src/integrations/gitlab/gitlab.client.d.ts

@@ -1,3 +1,11 @@
 import { Gitlab } from '@gitbeaker/rest';
 export declare function getGitlabClient(): InstanceType<typeof Gitlab>;
+/**
+ * Get the SHA of the latest commit on the default branch.
+ */
+export declare function getLatestCommitSha(client: InstanceType<typeof Gitlab>, projectId: number | string): Promise<string>;
+/**
+ * Download the repository archive as a Buffer.
+ */
+export declare function downloadArchive(client: InstanceType<typeof Gitlab>, projectId: number | string): Promise<Buffer>;
 //# sourceMappingURL=gitlab.client.d.ts.map

package/dist/src/integrations/gitlab/gitlab.client.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"gitlab.client.d.ts","sourceRoot":"","sources":["../../../../src/integrations/gitlab/gitlab.client.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAKzC,wBAAgB,eAAe,IAAI,YAAY,CAAC,OAAO,MAAM,CAAC,CAa7D"}
+{"version":3,"file":"gitlab.client.d.ts","sourceRoot":"","sources":["../../../../src/integrations/gitlab/gitlab.client.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAMzC,wBAAgB,eAAe,IAAI,YAAY,CAAC,OAAO,MAAM,CAAC,CAa7D;AAGD;;GAEG;AACH,wBAAsB,kBAAkB,CACpC,MAAM,EAAE,YAAY,CAAC,OAAO,MAAM,CAAC,EACnC,SAAS,EAAE,MAAM,GAAG,MAAM,GAC3B,OAAO,CAAC,MAAM,CAAC,CAQjB;AAED;;GAEG;AACH,wBAAsB,eAAe,CACjC,MAAM,EAAE,YAAY,CAAC,OAAO,MAAM,CAAC,EACnC,SAAS,EAAE,MAAM,GAAG,MAAM,GAC3B,OAAO,CAAC,MAAM,CAAC,CAIjB"}

package/dist/src/integrations/gitlab/gitlab.client.js

@@ -1,5 +1,6 @@
 import { Gitlab } from '@gitbeaker/rest';
 import { config } from '../../config/app.config.js';
+/* v8 ignore start -- gitbeaker singleton wiring, no custom logic */
 let gitlabClient = null;
 export function getGitlabClient() {
     if (!gitlabClient) {
@@ -13,3 +14,22 @@ export function getGitlabClient() {
     }
     return gitlabClient;
 }
+/* v8 ignore stop */
+/**
+ * Get the SHA of the latest commit on the default branch.
+ */
+export async function getLatestCommitSha(client, projectId) {
+    const commits = await client.Commits.all(projectId, { perPage: 1, maxPages: 1 });
+    if (commits.length === 0) {
+        throw new Error(`No commits found for project ${projectId}`);
+    }
+    return commits[0].id;
+}
+/**
+ * Download the repository archive as a Buffer.
+ */
+export async function downloadArchive(client, projectId) {
+    const blob = await client.Repositories.showArchive(projectId, { fileType: 'tar.gz' });
+    const arrayBuffer = await blob.arrayBuffer();
+    return Buffer.from(arrayBuffer);
+}

package/dist/src/integrations/gitlab/gitlab.client.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=gitlab.client.test.d.ts.map

package/dist/src/integrations/gitlab/gitlab.client.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gitlab.client.test.d.ts","sourceRoot":"","sources":["../../../../src/integrations/gitlab/gitlab.client.test.ts"],"names":[],"mappings":""}

package/dist/src/integrations/gitlab/gitlab.client.test.js

@@ -0,0 +1,62 @@
+import { describe, it, expect, vi } from 'vitest';
+import { getLatestCommitSha, downloadArchive } from './gitlab.client.js';
+function makeMockClient(overrides = {}) {
+    const commitsAll = overrides.commitsAll ?? vi.fn();
+    const repositoriesShowArchive = overrides.repositoriesShowArchive ?? vi.fn();
+    const client = {
+        Commits: { all: commitsAll },
+        Repositories: { showArchive: repositoriesShowArchive },
+    };
+    return { client, mocks: { commitsAll, repositoriesShowArchive } };
+}
+describe('getLatestCommitSha', () => {
+    it('returns the SHA of the latest commit', async () => {
+        const { client, mocks } = makeMockClient({
+            commitsAll: vi.fn().mockResolvedValue([
+                { id: 'abc123def456', short_id: 'abc123d', title: 'Latest commit' },
+            ]),
+        });
+        const sha = await getLatestCommitSha(client, 42);
+        expect(sha).toBe('abc123def456');
+        expect(mocks.commitsAll).toHaveBeenCalledWith(42, { perPage: 1, maxPages: 1 });
+    });
+    it('accepts string project IDs', async () => {
+        const { client, mocks } = makeMockClient({
+            commitsAll: vi.fn().mockResolvedValue([
+                { id: 'sha999', short_id: 'sha999' },
+            ]),
+        });
+        const sha = await getLatestCommitSha(client, 'group%2Fproject');
+        expect(sha).toBe('sha999');
+        expect(mocks.commitsAll).toHaveBeenCalledWith('group%2Fproject', { perPage: 1, maxPages: 1 });
+    });
+    it('throws when the commits array is empty', async () => {
+        const { client } = makeMockClient({
+            commitsAll: vi.fn().mockResolvedValue([]),
+        });
+        await expect(getLatestCommitSha(client, 42))
+            .rejects.toThrow('No commits found');
+    });
+});
+describe('downloadArchive', () => {
+    it('returns a Buffer with the archive contents', async () => {
+        const archiveData = new Uint8Array([0x1f, 0x8b, 0x08, 0x00]);
+        const blob = new Blob([archiveData]);
+        const { client, mocks } = makeMockClient({
+            repositoriesShowArchive: vi.fn().mockResolvedValue(blob),
+        });
+        const result = await downloadArchive(client, 42);
+        expect(result).toBeInstanceOf(Buffer);
+        expect(result.length).toBe(4);
+        expect(result[0]).toBe(0x1f);
+        expect(mocks.repositoriesShowArchive).toHaveBeenCalledWith(42, { fileType: 'tar.gz' });
+    });
+    it('accepts string project IDs', async () => {
+        const blob = new Blob([new Uint8Array([0x00])]);
+        const { client, mocks } = makeMockClient({
+            repositoriesShowArchive: vi.fn().mockResolvedValue(blob),
+        });
+        await downloadArchive(client, 'group%2Fproject');
+        expect(mocks.repositoriesShowArchive).toHaveBeenCalledWith('group%2Fproject', { fileType: 'tar.gz' });
+    });
+});

package/dist/src/integrations/jira/jira.client.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=jira.client.test.d.ts.map

package/dist/src/integrations/jira/jira.client.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jira.client.test.d.ts","sourceRoot":"","sources":["../../../../src/integrations/jira/jira.client.test.ts"],"names":[],"mappings":""}

package/dist/src/integrations/jira/jira.client.test.js

@@ -0,0 +1,171 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { JiraClient } from './jira.client.js';
+const BASE_URL = 'https://example.atlassian.net';
+function makeClient() {
+    return new JiraClient({ baseUrl: BASE_URL, email: 'test@test.com', apiToken: 'token' });
+}
+const issueFixture = {
+    id: '10001',
+    key: 'PROJ-1',
+    self: `${BASE_URL}/rest/api/3/issue/PROJ-1`,
+    fields: {
+        summary: 'Test Issue',
+        status: { name: 'In Progress', id: '1' },
+        issuetype: { name: 'Story', id: '1' },
+        project: { key: 'PROJ', id: '1', name: 'My Project' },
+        assignee: null,
+        reporter: null,
+        created: '2024-01-01T00:00:00.000Z',
+        updated: '2024-01-02T00:00:00.000Z',
+        resolutiondate: null,
+        labels: [],
+        components: [],
+    },
+};
+function makeCommentsResponse(comments) {
+    return { comments };
+}
+function makeAdfComment(content, displayName = 'John Doe') {
+    return {
+        id: '1',
+        author: { accountId: 'u1', displayName },
+        body: { type: 'doc', version: 1, content },
+        created: '2024-01-01T00:00:00.000Z',
+        updated: '2024-01-01T00:00:00.000Z',
+    };
+}
+function jsonResponse(data, status = 200) {
+    return new Response(JSON.stringify(data), {
+        status,
+        headers: { 'Content-Type': 'application/json' },
+    });
+}
+describe('JiraClient.getIssue', () => {
+    let fetchMock;
+    beforeEach(() => {
+        fetchMock = vi.fn();
+        vi.stubGlobal('fetch', fetchMock);
+    });
+    afterEach(() => {
+        vi.unstubAllGlobals();
+    });
+    it('returns issue with parsed ADF comments', async () => {
+        const comment = makeAdfComment([
+            { type: 'paragraph', content: [{ type: 'text', text: 'Hello world' }] },
+        ]);
+        fetchMock
+            .mockResolvedValueOnce(jsonResponse(issueFixture))
+            .mockResolvedValueOnce(jsonResponse(makeCommentsResponse([comment])));
+        const result = await makeClient().getIssue('PROJ-1');
+        expect(result.key).toBe('PROJ-1');
+        expect(result.comments).toHaveLength(1);
+        expect(result.comments[0].author).toBe('John Doe');
+        expect(result.comments[0].body).toContain('Hello world');
+    });
+    it('parses paragraph ADF node to plain text', async () => {
+        const comment = makeAdfComment([
+            { type: 'paragraph', content: [{ type: 'text', text: 'A paragraph.' }] },
+        ]);
+        fetchMock
+            .mockResolvedValueOnce(jsonResponse(issueFixture))
+            .mockResolvedValueOnce(jsonResponse(makeCommentsResponse([comment])));
+        const { comments } = await makeClient().getIssue('PROJ-1');
+        expect(comments[0].body).toBe('A paragraph.');
+    });
+    it('parses blockquote ADF node with > prefix', async () => {
+        const comment = makeAdfComment([
+            { type: 'blockquote', content: [
+                    { type: 'paragraph', content: [{ type: 'text', text: 'quoted text' }] },
+                ] },
+        ]);
+        fetchMock
+            .mockResolvedValueOnce(jsonResponse(issueFixture))
+            .mockResolvedValueOnce(jsonResponse(makeCommentsResponse([comment])));
+        const { comments } = await makeClient().getIssue('PROJ-1');
+        expect(comments[0].body).toContain('> ');
+        expect(comments[0].body).toContain('quoted text');
+    });
+    it('parses heading ADF node with ## prefix', async () => {
+        const comment = makeAdfComment([
+            { type: 'heading', content: [{ type: 'text', text: 'Section Header' }] },
+        ]);
+        fetchMock
+            .mockResolvedValueOnce(jsonResponse(issueFixture))
+            .mockResolvedValueOnce(jsonResponse(makeCommentsResponse([comment])));
+        const { comments } = await makeClient().getIssue('PROJ-1');
+        expect(comments[0].body).toContain('## Section Header');
+    });
+    it('parses listItem ADF node with - prefix', async () => {
+        const comment = makeAdfComment([
+            { type: 'listItem', content: [{ type: 'text', text: 'list item' }] },
+        ]);
+        fetchMock
+            .mockResolvedValueOnce(jsonResponse(issueFixture))
+            .mockResolvedValueOnce(jsonResponse(makeCommentsResponse([comment])));
+        const { comments } = await makeClient().getIssue('PROJ-1');
+        expect(comments[0].body).toContain('- list item');
+    });
+    it('parses codeBlock ADF node as fenced code', async () => {
+        const comment = makeAdfComment([
+            { type: 'codeBlock', content: [{ type: 'text', text: 'console.log("hi")' }] },
+        ]);
+        fetchMock
+            .mockResolvedValueOnce(jsonResponse(issueFixture))
+            .mockResolvedValueOnce(jsonResponse(makeCommentsResponse([comment])));
+        const { comments } = await makeClient().getIssue('PROJ-1');
+        expect(comments[0].body).toContain('```');
+        expect(comments[0].body).toContain('console.log("hi")');
+    });
+    it('parses mention ADF node using attrs.text', async () => {
+        const comment = makeAdfComment([
+            { type: 'paragraph', content: [
+                    { type: 'mention', attrs: { text: '@Jane', id: 'u2' } },
+                ] },
+        ]);
+        fetchMock
+            .mockResolvedValueOnce(jsonResponse(issueFixture))
+            .mockResolvedValueOnce(jsonResponse(makeCommentsResponse([comment])));
+        const { comments } = await makeClient().getIssue('PROJ-1');
+        expect(comments[0].body).toContain('@Jane');
+    });
+    it('passes through string comment body as-is', async () => {
+        const comment = {
+            id: '2',
+            author: { accountId: 'u1', displayName: 'Jane' },
+            body: 'plain string comment',
+            created: '2024-01-01T00:00:00.000Z',
+            updated: '2024-01-01T00:00:00.000Z',
+        };
+        fetchMock
+            .mockResolvedValueOnce(jsonResponse(issueFixture))
+            .mockResolvedValueOnce(jsonResponse(makeCommentsResponse([comment])));
+        const { comments } = await makeClient().getIssue('PROJ-1');
+        // String comments don't have type 'doc' so they are filtered out
+        expect(comments).toHaveLength(0);
+    });
+    it('filters out non-ADF comments (type !== "doc")', async () => {
+        const badComment = {
+            id: '3',
+            author: { accountId: 'u1', displayName: 'Bob' },
+            body: { type: 'unknown', content: [] },
+            created: '2024-01-01T00:00:00.000Z',
+            updated: '2024-01-01T00:00:00.000Z',
+        };
+        fetchMock
+            .mockResolvedValueOnce(jsonResponse(issueFixture))
+            .mockResolvedValueOnce(jsonResponse(makeCommentsResponse([badComment])));
+        const { comments } = await makeClient().getIssue('PROJ-1');
+        expect(comments).toHaveLength(0);
+    });
+    it('returns empty comments array when no comments exist', async () => {
+        fetchMock
+            .mockResolvedValueOnce(jsonResponse(issueFixture))
+            .mockResolvedValueOnce(jsonResponse(makeCommentsResponse([])));
+        const { comments } = await makeClient().getIssue('PROJ-1');
+        expect(comments).toEqual([]);
+    });
+    it('throws on non-ok HTTP response', async () => {
+        fetchMock.mockResolvedValueOnce(new Response('Not Found', { status: 404, statusText: 'Not Found' }));
+        await expect(makeClient().getIssue('PROJ-999')).rejects.toThrow('Jira API error: 404');
+    });
+});

package/dist/src/llm/anthropic-retry-wrapper.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=anthropic-retry-wrapper.test.d.ts.map

package/dist/src/llm/anthropic-retry-wrapper.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"anthropic-retry-wrapper.test.d.ts","sourceRoot":"","sources":["../../../src/llm/anthropic-retry-wrapper.test.ts"],"names":[],"mappings":""}