@hubblecommerce/overmind-core 0.1.4 → 0.1.5

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":""}

package/dist/src/llm/anthropic-retry-wrapper.test.js

@@ -0,0 +1,125 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { invokeWithRetry, RateLimitError } from './anthropic-retry-wrapper.js';
+function make429Error(overrides = {}) {
+    const err = new Error('rate limit exceeded');
+    err.status = 429;
+    return Object.assign(err, overrides);
+}
+describe('invokeWithRetry', () => {
+    beforeEach(() => { vi.useFakeTimers(); });
+    afterEach(() => { vi.useRealTimers(); });
+    it('returns result on first attempt', async () => {
+        const agent = { invoke: vi.fn().mockResolvedValue('result') };
+        expect(await invokeWithRetry(agent, 'input')).toBe('result');
+        expect(agent.invoke).toHaveBeenCalledOnce();
+    });
+    it('retries after 429 and returns result on second attempt', async () => {
+        const agent = { invoke: vi.fn() };
+        agent.invoke
+            .mockRejectedValueOnce(make429Error())
+            .mockResolvedValueOnce('result');
+        const promise = invokeWithRetry(agent, 'input');
+        await vi.runAllTimersAsync();
+        expect(await promise).toBe('result');
+        expect(agent.invoke).toHaveBeenCalledTimes(2);
+    });
+    it('throws RateLimitError after exhausting all retries', async () => {
+        const agent = { invoke: vi.fn().mockRejectedValue(make429Error()) };
+        const promise = invokeWithRetry(agent, 'input', 3);
+        // Attach rejection handler before running timers to avoid unhandled rejection warnings
+        const assertion = expect(promise).rejects.toBeInstanceOf(RateLimitError);
+        await vi.runAllTimersAsync();
+        await assertion;
+        expect(agent.invoke).toHaveBeenCalledTimes(3);
+    });
+    it('throws immediately on non-429 error without retrying', async () => {
+        const agent = { invoke: vi.fn().mockRejectedValue(new Error('Internal server error')) };
+        await expect(invokeWithRetry(agent, 'input')).rejects.toThrow('Internal server error');
+        expect(agent.invoke).toHaveBeenCalledOnce();
+    });
+    it('detects 429 via message containing "rate limit"', async () => {
+        const err = new Error('Claude rate limit reached');
+        const agent = { invoke: vi.fn() };
+        agent.invoke.mockRejectedValueOnce(err).mockResolvedValueOnce('ok');
+        const promise = invokeWithRetry(agent, 'input');
+        await vi.runAllTimersAsync();
+        expect(await promise).toBe('ok');
+    });
+    it('detects 429 via message containing "too many requests"', async () => {
+        const err = new Error('Too Many Requests from this endpoint');
+        const agent = { invoke: vi.fn() };
+        agent.invoke.mockRejectedValueOnce(err).mockResolvedValueOnce('ok');
+        const promise = invokeWithRetry(agent, 'input');
+        await vi.runAllTimersAsync();
+        expect(await promise).toBe('ok');
+    });
+    it('uses custom maxRetries count', async () => {
+        const agent = { invoke: vi.fn().mockRejectedValue(make429Error()) };
+        const promise = invokeWithRetry(agent, 'input', 2);
+        const assertion = expect(promise).rejects.toBeInstanceOf(RateLimitError);
+        await vi.runAllTimersAsync();
+        await assertion;
+        expect(agent.invoke).toHaveBeenCalledTimes(2);
+    });
+});
+describe('RateLimitError', () => {
+    it('is instanceof Error', () => {
+        expect(new RateLimitError('msg', 60)).toBeInstanceOf(Error);
+    });
+    it('has name RateLimitError', () => {
+        expect(new RateLimitError('msg', 60).name).toBe('RateLimitError');
+    });
+    it('stores retryAfterSeconds', () => {
+        expect(new RateLimitError('msg', 30).retryAfterSeconds).toBe(30);
+    });
+    it('stores null retryAfterSeconds', () => {
+        expect(new RateLimitError('msg', null).retryAfterSeconds).toBeNull();
+    });
+});
+describe('extractRetryAfter (tested via RateLimitError on exhaustion)', () => {
+    beforeEach(() => { vi.useFakeTimers(); });
+    afterEach(() => { vi.useRealTimers(); });
+    async function exhaustAndGetError(err) {
+        const agent = { invoke: vi.fn().mockRejectedValue(err) };
+        const promise = invokeWithRetry(agent, 'input', 3);
+        // Attach handler before running timers to prevent unhandled rejection warnings
+        let caughtError;
+        promise.catch((e) => { caughtError = e; });
+        await vi.runAllTimersAsync();
+        return caughtError;
+    }
+    it('reads retry-after from error.headers', async () => {
+        const err = make429Error({ headers: { 'retry-after': '45' } });
+        const result = await exhaustAndGetError(err);
+        expect(result.retryAfterSeconds).toBe(45);
+    });
+    it('reads retry-after from error.response.headers as plain object', async () => {
+        const err = make429Error({ response: { headers: { 'retry-after': '30' } } });
+        const result = await exhaustAndGetError(err);
+        expect(result.retryAfterSeconds).toBe(30);
+    });
+    it('reads retry-after from error.response.headers.get() (fetch Headers interface)', async () => {
+        const err = make429Error({
+            response: {
+                headers: { get: (key) => key === 'retry-after' ? '20' : undefined },
+            },
+        });
+        const result = await exhaustAndGetError(err);
+        expect(result.retryAfterSeconds).toBe(20);
+    });
+    it('reads retry-after from error.error.headers (nested shape)', async () => {
+        const err = make429Error({ error: { headers: { 'retry-after': '15' } } });
+        const result = await exhaustAndGetError(err);
+        expect(result.retryAfterSeconds).toBe(15);
+    });
+    it('returns null retryAfterSeconds when no header present', async () => {
+        const err = make429Error();
+        const result = await exhaustAndGetError(err);
+        expect(result.retryAfterSeconds).toBeNull();
+    });
+    it('returns null retryAfterSeconds when retry-after is not a valid integer', async () => {
+        const err = make429Error({ headers: { 'retry-after': 'not-a-number' } });
+        const result = await exhaustAndGetError(err);
+        expect(result.retryAfterSeconds).toBeNull();
+    });
+});

package/dist/src/processors/confluence-document.processor.test.d.ts

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

package/dist/src/processors/confluence-document.processor.test.d.ts.map

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

package/dist/src/processors/confluence-document.processor.test.js

@@ -0,0 +1,202 @@
+import { describe, it, expect } from 'vitest';
+import { splitMarkdownBySections, processConfluencePage } from './confluence-document.processor.js';
+function makePage(overrides) {
+    const { html, ...rest } = overrides;
+    return {
+        id: 'page1',
+        status: 'current',
+        title: 'Test Page',
+        spaceId: 'SPACE1',
+        authorId: 'author1',
+        createdAt: '2024-01-01T00:00:00.000Z',
+        version: {
+            createdAt: '2024-01-02T00:00:00.000Z',
+            message: '',
+            number: 1,
+            minorEdit: false,
+            authorId: 'author1',
+        },
+        body: {
+            storage: {
+                value: html ?? '<p>Default content</p>',
+                representation: 'storage',
+            },
+        },
+        _links: { webui: '/spaces/TEST/pages/page1/Test+Page' },
+        ...rest,
+    };
+}
+describe('splitMarkdownBySections', () => {
+    it('returns a single chunk with undefined sectionTitle when no H2 headings', () => {
+        const chunks = splitMarkdownBySections('Some content without headings');
+        expect(chunks).toHaveLength(1);
+        expect(chunks[0].sectionTitle).toBeUndefined();
+        expect(chunks[0].sectionIndex).toBe(0);
+        expect(chunks[0].content).toBe('Some content without headings');
+    });
+    it('returns N chunks for N H2 headings', () => {
+        const md = '## First\nContent A\n## Second\nContent B\n## Third\nContent C';
+        expect(splitMarkdownBySections(md)).toHaveLength(3);
+    });
+    it('chunk sectionTitle matches the H2 heading text', () => {
+        const md = '## My Heading\nSome text';
+        const [chunk] = splitMarkdownBySections(md);
+        expect(chunk.sectionTitle).toBe('My Heading');
+    });
+    it('sectionIndex is 0-based and sequential', () => {
+        const md = '## A\ntext\n## B\ntext\n## C\ntext';
+        const chunks = splitMarkdownBySections(md);
+        expect(chunks.map(c => c.sectionIndex)).toEqual([0, 1, 2]);
+    });
+    it('each chunk content starts with the ## heading line', () => {
+        const md = '## Section One\nContent here';
+        const [chunk] = splitMarkdownBySections(md);
+        expect(chunk.content).toMatch(/^## Section One/);
+    });
+    it('H3 and H4 headings do not split sections', () => {
+        const md = '## Section\n### Sub A\n#### Sub B\nContent';
+        expect(splitMarkdownBySections(md)).toHaveLength(1);
+    });
+    it('trims whitespace from chunk content', () => {
+        const md = '## Title\n\n  Content  \n\n';
+        const [chunk] = splitMarkdownBySections(md);
+        expect(chunk.content).toBe(chunk.content.trim());
+    });
+    it('returns empty string content as a single chunk', () => {
+        const chunks = splitMarkdownBySections('');
+        expect(chunks).toHaveLength(1);
+        expect(chunks[0].content).toBe('');
+    });
+});
+describe('processConfluencePage', () => {
+    const BASE_URL = 'https://example.atlassian.net';
+    const SPACE_KEY = 'TEST';
+    it('returns empty array when page has no body content', () => {
+        const page = makePage({ body: undefined });
+        expect(processConfluencePage(page, SPACE_KEY, BASE_URL)).toEqual([]);
+    });
+    it('returns empty array when page body value is empty string', () => {
+        const page = makePage({ html: '' });
+        expect(processConfluencePage(page, SPACE_KEY, BASE_URL)).toHaveLength(0);
+    });
+    it('document_id uses format confluence:{spaceKey}:{pageId}_section_{index}', () => {
+        const page = makePage({ id: 'abc123', html: '<p>Hello</p>' });
+        const [doc] = processConfluencePage(page, 'PROJ', BASE_URL);
+        expect(doc.metadata.document_id).toBe('confluence:PROJ:abc123_section_0');
+    });
+    it('strips trailing slash from baseUrl when constructing page_url', () => {
+        const page = makePage({ html: '<p>Hello</p>' });
+        const [doc] = processConfluencePage(page, SPACE_KEY, 'https://example.atlassian.net/');
+        // Trailing slash stripped: result should be /wiki/spaces/... not //wiki/spaces/...
+        expect(doc.metadata.page_url).not.toContain('//wiki');
+        expect(doc.metadata.page_url).toContain('https://example.atlassian.net/wiki');
+    });
+    it('page_url includes the page webui path', () => {
+        const page = makePage({ html: '<p>Hello</p>' });
+        const [doc] = processConfluencePage(page, SPACE_KEY, BASE_URL);
+        expect(doc.metadata.page_url).toContain(page._links.webui);
+    });
+    it('chunk_type is full_page when there are no H2 headings', () => {
+        const page = makePage({ html: '<p>Simple content with no headings</p>' });
+        const [doc] = processConfluencePage(page, SPACE_KEY, BASE_URL);
+        expect(doc.metadata.chunk_type).toBe('full_page');
+    });
+    it('chunk_type is section when H2 headings are present', () => {
+        const page = makePage({ html: '<h2>Section</h2><p>Content</p>' });
+        const docs = processConfluencePage(page, SPACE_KEY, BASE_URL);
+        expect(docs[0].metadata.chunk_type).toBe('section');
+    });
+    it('page with two H2s produces two documents', () => {
+        const page = makePage({ html: '<h2>Part A</h2><p>First</p><h2>Part B</h2><p>Second</p>' });
+        expect(processConfluencePage(page, SPACE_KEY, BASE_URL)).toHaveLength(2);
+    });
+    it('metadata.source is always "confluence"', () => {
+        const page = makePage({ html: '<p>Hello</p>' });
+        const [doc] = processConfluencePage(page, SPACE_KEY, BASE_URL);
+        expect(doc.metadata.source).toBe('confluence');
+    });
+    it('metadata.document_type is always "confluence_page"', () => {
+        const page = makePage({ html: '<p>Hello</p>' });
+        const [doc] = processConfluencePage(page, SPACE_KEY, BASE_URL);
+        expect(doc.metadata.document_type).toBe('confluence_page');
+    });
+    it('passes labels through to metadata', () => {
+        const page = makePage({ html: '<p>Hello</p>' });
+        const [doc] = processConfluencePage(page, SPACE_KEY, BASE_URL, ['faq', 'active']);
+        expect(doc.metadata.labels).toEqual(['faq', 'active']);
+    });
+    describe('label metadata extraction', () => {
+        it('maps "project-info" label to content_type', () => {
+            const page = makePage({ html: '<p>Hello</p>' });
+            const [doc] = processConfluencePage(page, SPACE_KEY, BASE_URL, ['project-info']);
+            expect(doc.metadata.content_type).toBe('project-info');
+        });
+        it('maps "faq" label to content_type', () => {
+            const page = makePage({ html: '<p>Hello</p>' });
+            const [doc] = processConfluencePage(page, SPACE_KEY, BASE_URL, ['faq']);
+            expect(doc.metadata.content_type).toBe('faq');
+        });
+        it('maps "customer-acme" label to customer field', () => {
+            const page = makePage({ html: '<p>Hello</p>' });
+            const [doc] = processConfluencePage(page, SPACE_KEY, BASE_URL, ['customer-acme']);
+            expect(doc.metadata.customer).toBe('customer-acme');
+        });
+        it('maps "active" label to category', () => {
+            const page = makePage({ html: '<p>Hello</p>' });
+            const [doc] = processConfluencePage(page, SPACE_KEY, BASE_URL, ['active']);
+            expect(doc.metadata.category).toBe('active');
+        });
+        it('maps "archived" label to category', () => {
+            const page = makePage({ html: '<p>Hello</p>' });
+            const [doc] = processConfluencePage(page, SPACE_KEY, BASE_URL, ['archived']);
+            expect(doc.metadata.category).toBe('archived');
+        });
+        it('remaining labels go to keywords', () => {
+            const page = makePage({ html: '<p>Hello</p>' });
+            const [doc] = processConfluencePage(page, SPACE_KEY, BASE_URL, ['shopware', 'v6', 'backend']);
+            expect(doc.metadata.keywords).toEqual(['shopware', 'v6', 'backend']);
+        });
+        it('categorized labels are NOT duplicated in keywords', () => {
+            const page = makePage({ html: '<p>Hello</p>' });
+            const [doc] = processConfluencePage(page, SPACE_KEY, BASE_URL, ['faq', 'active', 'customer-xyz', 'shopware']);
+            expect(doc.metadata.keywords).toEqual(['shopware']);
+            expect(doc.metadata.keywords).not.toContain('faq');
+            expect(doc.metadata.keywords).not.toContain('active');
+            expect(doc.metadata.keywords).not.toContain('customer-xyz');
+        });
+        it('empty labels result in undefined content_type, customer, category and empty keywords', () => {
+            const page = makePage({ html: '<p>Hello</p>' });
+            const [doc] = processConfluencePage(page, SPACE_KEY, BASE_URL, []);
+            expect(doc.metadata.content_type).toBeUndefined();
+            expect(doc.metadata.customer).toBeUndefined();
+            expect(doc.metadata.category).toBeUndefined();
+            expect(doc.metadata.keywords).toEqual([]);
+        });
+    });
+    describe('content analysis', () => {
+        it('has_code_blocks is true when content contains triple backtick', () => {
+            // Use a Confluence code macro so the HTML parser produces backticks
+            const html = `<ac:structured-macro ac:name="code">
+                <ac:plain-text-body>const x = 1;</ac:plain-text-body>
+            </ac:structured-macro>`;
+            const page = makePage({ html });
+            const [doc] = processConfluencePage(page, SPACE_KEY, BASE_URL);
+            expect(doc.metadata.has_code_blocks).toBe(true);
+        });
+        it('has_code_blocks is false when content has no code blocks', () => {
+            const page = makePage({ html: '<p>Plain text only</p>' });
+            const [doc] = processConfluencePage(page, SPACE_KEY, BASE_URL);
+            expect(doc.metadata.has_code_blocks).toBe(false);
+        });
+        it('has_links is true when content contains a markdown link', () => {
+            const page = makePage({ html: '<a href="https://example.com">click</a>' });
+            const [doc] = processConfluencePage(page, SPACE_KEY, BASE_URL);
+            expect(doc.metadata.has_links).toBe(true);
+        });
+        it('word_count reflects number of words in content', () => {
+            const page = makePage({ html: '<p>one two three four five</p>' });
+            const [doc] = processConfluencePage(page, SPACE_KEY, BASE_URL);
+            expect(doc.metadata.word_count).toBe(5);
+        });
+    });
+});

package/dist/src/processors/confluence-html-parser.test.d.ts

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

package/dist/src/processors/confluence-html-parser.test.d.ts.map

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

package/dist/src/processors/confluence-html-parser.test.js

@@ -0,0 +1,214 @@
+import { describe, it, expect } from 'vitest';
+import { parseConfluenceHtml } from './confluence-html-parser.js';
+describe('parseConfluenceHtml', () => {
+    describe('basic HTML conversion', () => {
+        it('converts h2 to ## heading', () => {
+            expect(parseConfluenceHtml('<h2>My Section</h2>')).toBe('## My Section');
+        });
+        it('converts h1 to # heading', () => {
+            expect(parseConfluenceHtml('<h1>Title</h1>')).toBe('# Title');
+        });
+        it('converts strong to **bold**', () => {
+            expect(parseConfluenceHtml('<p><strong>bold text</strong></p>')).toContain('**bold text**');
+        });
+        it('converts inline code to backtick', () => {
+            expect(parseConfluenceHtml('<p><code>myFunc()</code></p>')).toContain('`myFunc()`');
+        });
+        it('converts anchor tag to markdown link', () => {
+            const result = parseConfluenceHtml('<a href="https://example.com">click here</a>');
+            expect(result).toContain('[click here](https://example.com)');
+        });
+    });
+    describe('whitespace cleanup', () => {
+        it('collapses 3+ consecutive newlines to 2', () => {
+            const html = '<p>First</p>\n\n\n\n<p>Second</p>';
+            const result = parseConfluenceHtml(html);
+            expect(result).not.toMatch(/\n{3,}/);
+        });
+        it('removes trailing spaces from lines', () => {
+            const result = parseConfluenceHtml('<p>Hello world</p>');
+            const lines = result.split('\n');
+            for (const line of lines) {
+                expect(line).toBe(line.trimEnd());
+            }
+        });
+        it('trims leading and trailing whitespace', () => {
+            const result = parseConfluenceHtml('<p>Hello</p>');
+            expect(result).toBe(result.trim());
+        });
+    });
+    describe('Confluence code macro', () => {
+        it('renders code macro as fenced code block', () => {
+            const html = `<ac:structured-macro ac:name="code">
+                <ac:plain-text-body>const x = 1;</ac:plain-text-body>
+            </ac:structured-macro>`;
+            const result = parseConfluenceHtml(html);
+            expect(result).toContain('```');
+            expect(result).toContain('const x = 1;');
+        });
+        it('includes language when parameter is present', () => {
+            const html = `<ac:structured-macro ac:name="code">
+                <ac:parameter ac:name="language">javascript</ac:parameter>
+                <ac:plain-text-body>const x = 1;</ac:plain-text-body>
+            </ac:structured-macro>`;
+            const result = parseConfluenceHtml(html);
+            expect(result).toContain('```javascript');
+        });
+    });
+    describe('Confluence panel macros', () => {
+        it('renders info macro as blockquote with INFO label', () => {
+            const html = `<ac:structured-macro ac:name="info">
+                <ac:rich-text-body><p>Important info</p></ac:rich-text-body>
+            </ac:structured-macro>`;
+            const result = parseConfluenceHtml(html);
+            expect(result).toContain('> **INFO**');
+        });
+        it('renders warning macro as blockquote with WARNING label', () => {
+            const html = `<ac:structured-macro ac:name="warning">
+                <ac:rich-text-body><p>Be careful</p></ac:rich-text-body>
+            </ac:structured-macro>`;
+            const result = parseConfluenceHtml(html);
+            expect(result).toContain('> **WARNING**');
+        });
+        it('renders tip macro as blockquote with TIP label', () => {
+            const html = `<ac:structured-macro ac:name="tip">
+                <ac:rich-text-body><p>A helpful tip</p></ac:rich-text-body>
+            </ac:structured-macro>`;
+            const result = parseConfluenceHtml(html);
+            expect(result).toContain('> **TIP**');
+        });
+        it('renders note macro as blockquote with NOTE label', () => {
+            const html = `<ac:structured-macro ac:name="note">
+                <ac:rich-text-body><p>Take note</p></ac:rich-text-body>
+            </ac:structured-macro>`;
+            const result = parseConfluenceHtml(html);
+            expect(result).toContain('> **NOTE**');
+        });
+    });
+    describe('Confluence TOC macro', () => {
+        it('renders toc macro as Table of Contents text', () => {
+            // Real Confluence TOC macros include parameters — an empty element is
+            // not matched by the filter in some DOM parsers
+            const html = `<ac:structured-macro ac:name="toc">
+                <ac:parameter ac:name="maxLevel">3</ac:parameter>
+            </ac:structured-macro>`;
+            const result = parseConfluenceHtml(html);
+            expect(result).toContain('**Table of Contents**');
+        });
+    });
+    describe('Confluence JIRA macro', () => {
+        it('renders jira macro with key as JIRA Issue reference', () => {
+            const html = `<ac:structured-macro ac:name="jira">
+                <ac:parameter ac:name="key">PROJ-123</ac:parameter>
+            </ac:structured-macro>`;
+            const result = parseConfluenceHtml(html);
+            expect(result).toContain('**JIRA Issue:** PROJ-123');
+        });
+        it('renders empty string when jira macro has no key', () => {
+            const html = `<ac:structured-macro ac:name="jira"></ac:structured-macro>`;
+            const result = parseConfluenceHtml(html);
+            expect(result).not.toContain('JIRA Issue');
+        });
+    });
+    describe('Confluence status macro', () => {
+        it('renders status macro as **[title]**', () => {
+            const html = `<ac:structured-macro ac:name="status">
+                <ac:parameter ac:name="title">IN PROGRESS</ac:parameter>
+            </ac:structured-macro>`;
+            const result = parseConfluenceHtml(html);
+            expect(result).toContain('**[IN PROGRESS]**');
+        });
+        it('appends color in parentheses when colour parameter is present', () => {
+            const html = `<ac:structured-macro ac:name="status">
+                <ac:parameter ac:name="title">DONE</ac:parameter>
+                <ac:parameter ac:name="colour">Green</ac:parameter>
+            </ac:structured-macro>`;
+            const result = parseConfluenceHtml(html);
+            expect(result).toContain('(Green)');
+        });
+    });
+    describe('Confluence anchor macro', () => {
+        it('renders anchor macro as named anchor tag', () => {
+            const html = `<ac:structured-macro ac:name="anchor">
+                <ac:parameter>my-anchor</ac:parameter>
+            </ac:structured-macro>`;
+            const result = parseConfluenceHtml(html);
+            expect(result).toContain('<a name="my-anchor"></a>');
+        });
+        it('renders empty string when anchor has no parameter text', () => {
+            const html = `<ac:structured-macro ac:name="anchor">
+                <ac:parameter></ac:parameter>
+            </ac:structured-macro>`;
+            const result = parseConfluenceHtml(html);
+            expect(result).not.toContain('<a name=');
+        });
+    });
+    describe('Confluence excerpt macro', () => {
+        it('returns rich-text-body content for excerpt macro', () => {
+            const html = `<ac:structured-macro ac:name="excerpt">
+                <ac:rich-text-body><p>Excerpt content</p></ac:rich-text-body>
+            </ac:structured-macro>`;
+            const result = parseConfluenceHtml(html);
+            expect(result).toContain('Excerpt content');
+        });
+    });
+    describe('Confluence expand macro', () => {
+        it('renders expand macro with title and body', () => {
+            const html = `<ac:structured-macro ac:name="expand">
+                <ac:parameter ac:name="title">Click to expand</ac:parameter>
+                <ac:rich-text-body><p>Hidden content</p></ac:rich-text-body>
+            </ac:structured-macro>`;
+            const result = parseConfluenceHtml(html);
+            expect(result).toContain('**Click to expand**');
+            expect(result).toContain('Hidden content');
+        });
+        it('uses "Details" as default title when no title parameter', () => {
+            const html = `<ac:structured-macro ac:name="expand">
+                <ac:rich-text-body><p>Some content</p></ac:rich-text-body>
+            </ac:structured-macro>`;
+            const result = parseConfluenceHtml(html);
+            expect(result).toContain('**Details**');
+        });
+    });
+    describe('Confluence quote macro', () => {
+        it('renders quote macro as blockquote', () => {
+            const html = `<ac:structured-macro ac:name="quote">
+                <ac:rich-text-body><p>A famous quote</p></ac:rich-text-body>
+            </ac:structured-macro>`;
+            const result = parseConfluenceHtml(html);
+            expect(result).toContain('> ');
+            expect(result).toContain('A famous quote');
+        });
+    });
+    describe('Confluence link macro', () => {
+        it('renders ac:link with ri:page as markdown link using content-title', () => {
+            const html = `<ac:link><ri:page ri:content-title="My Page"/><ac:plain-text-link-body>My Page</ac:plain-text-link-body></ac:link>`;
+            const result = parseConfluenceHtml(html);
+            expect(result).toContain('[My Page](My Page)');
+        });
+        it('renders ac:link without href as plain text', () => {
+            const html = `<ac:link><ac:plain-text-link-body>Just text</ac:plain-text-link-body></ac:link>`;
+            const result = parseConfluenceHtml(html);
+            expect(result).toContain('Just text');
+        });
+    });
+    describe('Confluence unknown macro', () => {
+        it('falls back to text content for unknown macros', () => {
+            const html = `<ac:structured-macro ac:name="unknown-macro">
+                <ac:rich-text-body><p>Fallback text</p></ac:rich-text-body>
+            </ac:structured-macro>`;
+            const result = parseConfluenceHtml(html);
+            expect(result).toContain('Fallback text');
+        });
+    });
+    describe('Confluence JIRA macro with server', () => {
+        it('includes server name when present', () => {
+            const html = `<ac:structured-macro ac:name="jira">
+                <ac:parameter ac:name="key">PROJ-456</ac:parameter>
+                <ac:parameter ac:name="server">My Jira</ac:parameter>
+            </ac:structured-macro>`;
+            const result = parseConfluenceHtml(html);
+            expect(result).toContain('(My Jira)');
+        });
+    });
+});

package/dist/src/tools/confluence-search.tool.d.ts

@@ -22,7 +22,7 @@ export declare function createConfluenceAgentTool(vectorStore: VectorStoreProvid
         parent_page_id: z.ZodOptional<z.ZodString>;
     }, "strip", z.ZodTypeAny, {
         keywords?: string[] | undefined;
-        content_type?: "template" | "project-info" | "faq" | "guide" | "decision" | undefined;
+        content_type?: "project-info" | "template" | "faq" | "guide" | "decision" | undefined;
         customer?: string | undefined;
         category?: "archived" | "active" | "maintenance" | "legacy" | undefined;
         space_key?: string | undefined;
@@ -36,7 +36,7 @@ export declare function createConfluenceAgentTool(vectorStore: VectorStoreProvid
         parent_page_id?: string | undefined;
     }, {
         keywords?: string[] | undefined;
-        content_type?: "template" | "project-info" | "faq" | "guide" | "decision" | undefined;
+        content_type?: "project-info" | "template" | "faq" | "guide" | "decision" | undefined;
         customer?: string | undefined;
         category?: "archived" | "active" | "maintenance" | "legacy" | undefined;
         space_key?: string | undefined;
@@ -53,7 +53,7 @@ export declare function createConfluenceAgentTool(vectorStore: VectorStoreProvid
     query: string;
     filters?: {
         keywords?: string[] | undefined;
-        content_type?: "template" | "project-info" | "faq" | "guide" | "decision" | undefined;
+        content_type?: "project-info" | "template" | "faq" | "guide" | "decision" | undefined;
         customer?: string | undefined;
         category?: "archived" | "active" | "maintenance" | "legacy" | undefined;
         space_key?: string | undefined;
@@ -70,7 +70,7 @@ export declare function createConfluenceAgentTool(vectorStore: VectorStoreProvid
     query: string;
     filters?: {
         keywords?: string[] | undefined;
-        content_type?: "template" | "project-info" | "faq" | "guide" | "decision" | undefined;
+        content_type?: "project-info" | "template" | "faq" | "guide" | "decision" | undefined;
         customer?: string | undefined;
         category?: "archived" | "active" | "maintenance" | "legacy" | undefined;
         space_key?: string | undefined;
@@ -87,7 +87,7 @@ export declare function createConfluenceAgentTool(vectorStore: VectorStoreProvid
     query: string;
     filters?: {
         keywords?: string[] | undefined;
-        content_type?: "template" | "project-info" | "faq" | "guide" | "decision" | undefined;
+        content_type?: "project-info" | "template" | "faq" | "guide" | "decision" | undefined;
         customer?: string | undefined;
         category?: "archived" | "active" | "maintenance" | "legacy" | undefined;
         space_key?: string | undefined;
@@ -104,7 +104,7 @@ export declare function createConfluenceAgentTool(vectorStore: VectorStoreProvid
     query: string;
     filters?: {
         keywords?: string[] | undefined;
-        content_type?: "template" | "project-info" | "faq" | "guide" | "decision" | undefined;
+        content_type?: "project-info" | "template" | "faq" | "guide" | "decision" | undefined;
         customer?: string | undefined;
         category?: "archived" | "active" | "maintenance" | "legacy" | undefined;
         space_key?: string | undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hubblecommerce/overmind-core",
-  "version": "0.1.4",
+  "version": "0.1.5",
   "type": "module",
   "description": "Shared infrastructure package for the Overmind AI agent system",
   "main": "./dist/src/index.js",
@@ -67,6 +67,9 @@
     "zod": "^3.25.76"
   },
   "scripts": {
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
     "build": "tsc",
     "prepack": "npm run build",
     "typecheck": "tsc --noEmit",
@@ -84,12 +87,14 @@
     "@types/node": "^24.6.1",
     "@types/pg": "^8.15.5",
     "@types/turndown": "^5.0.5",
+    "@vitest/coverage-v8": "^4.1.2",
     "eslint": "^9.36.0",
     "husky": "^9.0.0",
     "lint-staged": "^15.0.0",
     "tsx": "^4.20.6",
     "typescript": "^5.9.3",
-    "typescript-eslint": "^8.45.0"
+    "typescript-eslint": "^8.45.0",
+    "vitest": "^4.1.2"
   },
   "lint-staged": {
     "*.ts": "eslint --fix"