@hubblecommerce/overmind-core 0.1.3 → 0.1.5

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

@@ -5,6 +5,19 @@ export class JiraClient {
         this.baseUrl = config.baseUrl;
         this.authHeader = 'Basic ' + Buffer.from(`${config.email}:${config.apiToken}`).toString('base64');
     }
+    async request(endpoint) {
+        const response = await fetch(`${this.baseUrl}${endpoint}`, {
+            headers: {
+                'Authorization': this.authHeader,
+                'Accept': 'application/json',
+                'Content-Type': 'application/json',
+            },
+        });
+        if (!response.ok) {
+            throw new Error(`Jira API error: ${response.status} ${response.statusText}`);
+        }
+        return response.json();
+    }
     /**
      * Parse Atlassian Document Format (ADF) to plain text
      */
@@ -55,92 +68,16 @@ export class JiraClient {
      */
     async getIssue(issueKeyOrId) {
         try {
-            // Fetch issue details
-            const issueResponse = await fetch(`${this.baseUrl}/rest/api/3/issue/${issueKeyOrId}`, {
-                headers: {
-                    'Authorization': this.authHeader,
-                    'Content-Type': 'application/json',
-                    'Accept': 'application/json',
-                },
-            });
-            if (!issueResponse.ok) {
-                throw new Error(`Failed to fetch issue: ${issueResponse.status} ${issueResponse.statusText}`);
-            }
-            const issue = await issueResponse.json();
-            // Fetch comments
-            const commentsResponse = await fetch(`${this.baseUrl}/rest/api/3/issue/${issueKeyOrId}/comment`, {
-                headers: {
-                    'Authorization': this.authHeader,
-                    'Content-Type': 'application/json',
-                    'Accept': 'application/json',
-                },
-            });
-            if (!commentsResponse.ok) {
-                throw new Error(`Failed to fetch comments: ${commentsResponse.status} ${commentsResponse.statusText}`);
-            }
-            const commentsData = await commentsResponse.json();
-            // Parse and filter comments (only 'doc' type, latest version only)
-            const commentsMap = new Map();
-            commentsData.comments?.forEach(comment => {
-                // Only include ADF doc type comments
-                if (typeof comment.body === 'object' && comment.body !== null) {
-                    const adfDoc = comment.body;
-                    if (adfDoc.type !== 'doc') {
-                        return;
-                    }
-                    const version = adfDoc.version || 1;
-                    const existing = commentsMap.get(comment.id);
-                    // Only keep the latest version of each comment
-                    if (!existing || version > existing.version) {
-                        commentsMap.set(comment.id, {
-                            author: comment.author.displayName,
-                            body: this.parseCommentBody(comment.body),
-                            updated: comment.updated,
-                            version,
-                        });
-                    }
-                }
-            });
-            // Convert map to array (without version field)
-            // eslint-disable-next-line @typescript-eslint/no-unused-vars
-            const parsedComments = Array.from(commentsMap.values()).map(({ version, ...comment }) => comment);
-            // Transform to our interface
-            return {
-                id: issue.id,
-                key: issue.key,
-                self: issue.self,
-                fields: {
-                    summary: issue.fields.summary,
-                    description: issue.fields.description,
-                    status: {
-                        name: issue.fields.status.name,
-                        id: issue.fields.status.id,
-                    },
-                    issuetype: {
-                        name: issue.fields.issuetype.name,
-                        id: issue.fields.issuetype.id,
-                    },
-                    project: {
-                        key: issue.fields.project.key,
-                        id: issue.fields.project.id,
-                        name: issue.fields.project.name,
-                    },
-                    assignee: issue.fields.assignee ? {
-                        accountId: issue.fields.assignee.accountId,
-                        displayName: issue.fields.assignee.displayName,
-                    } : null,
-                    reporter: issue.fields.reporter ? {
-                        accountId: issue.fields.reporter.accountId,
-                        displayName: issue.fields.reporter.displayName,
-                    } : null,
-                    created: issue.fields.created,
-                    updated: issue.fields.updated,
-                    resolutiondate: issue.fields.resolutiondate,
-                    labels: issue.fields.labels || [],
-                    components: issue.fields.components || [],
-                },
-                comments: parsedComments,
-            };
+            const issue = await this.request(`/rest/api/3/issue/${issueKeyOrId}`);
+            const commentsData = await this.request(`/rest/api/3/issue/${issueKeyOrId}/comment`);
+            const parsedComments = commentsData.comments
+                ?.filter(c => typeof c.body === 'object' && c.body !== null && c.body.type === 'doc')
+                .map(c => ({
+                author: c.author.displayName,
+                body: this.parseCommentBody(c.body),
+                updated: c.updated,
+            })) ?? [];
+            return { ...issue, comments: parsedComments };
         }
         catch (error) {
             console.error(`[JiraClient] Error fetching issue ${issueKeyOrId}:`, error);

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