@hubblecommerce/overmind-core 0.1.4 → 0.1.6

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/dist/src/utils/repomix-search.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Repomix search utilities — pure string/regex operations, no filesystem dependency.
+ * Core search logic adapted from repomix (https://github.com/yamadashy/repomix)
+ * src/mcp/tools/grepRepomixOutputTool.ts
+ */
+interface SearchMatch {
+    lineNumber: number;
+    line: string;
+    matchedText: string;
+}
+interface SearchResult {
+    matches: SearchMatch[];
+    formattedOutput: string[];
+}
+interface SearchOptions {
+    ignoreCase?: boolean;
+    contextLines?: number;
+}
+/**
+ * Search a repomix XML string for lines matching a pattern.
+ * Returns matching lines with optional context.
+ */
+export declare function searchRepomix(xml: string, pattern: string, options?: SearchOptions): SearchResult;
+/**
+ * Extract the content of a specific file block from repomix XML.
+ * Looks for `<file path="filePath">...</file>` and returns the inner content.
+ * Returns null if the file is not found.
+ */
+export declare function getRepomixFile(xml: string, filePath: string): string | null;
+export {};
+//# sourceMappingURL=repomix-search.d.ts.map

package/dist/src/utils/repomix-search.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"repomix-search.d.ts","sourceRoot":"","sources":["../../../src/utils/repomix-search.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,UAAU,WAAW;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;CACvB;AAED,UAAU,YAAY;IAClB,OAAO,EAAE,WAAW,EAAE,CAAC;IACvB,eAAe,EAAE,MAAM,EAAE,CAAC;CAC7B;AAED,UAAU,aAAa;IACnB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,YAAY,CAAC,EAAE,MAAM,CAAC;CACzB;AAsED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,aAAa,GAAG,YAAY,CASjG;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAQ3E"}