@aaronshaf/confluence-cli 0.1.15

package/src/test/link-conversion-integration.test.ts

@@ -0,0 +1,189 @@
+import { describe, expect, test } from 'bun:test';
+import { MarkdownConverter } from '../lib/markdown/converter.js';
+import { HtmlConverter } from '../lib/markdown/html-converter.js';
+import { parseMarkdown } from '../lib/markdown/frontmatter.js';
+import { buildPageLookupMapFromCache } from '../lib/markdown/link-converter.js';
+import type { PageStateCache, FullPageInfo } from '../lib/page-state.js';
+
+/**
+ * Helper to create PageStateCache from a simple record
+ */
+function createPageStateCache(
+  pages: Record<string, { pageId: string; localPath: string; title: string }>,
+): PageStateCache {
+  const pagesMap = new Map<string, FullPageInfo>();
+  const pathToPageId = new Map<string, string>();
+
+  for (const [pageId, info] of Object.entries(pages)) {
+    pagesMap.set(pageId, {
+      pageId: info.pageId,
+      localPath: info.localPath,
+      title: info.title,
+      version: 1,
+    });
+    pathToPageId.set(info.localPath, pageId);
+  }
+
+  return { pages: pagesMap, pathToPageId };
+}
+
+describe('Link Conversion Integration Tests', () => {
+  // TODO: This test requires enhancements to turndown parsing of ac:link elements
+  // The link conversion logic is implemented correctly, but turndown needs custom
+  // handling for CDATA content in ac:plain-text-link-body elements
+  test.skip('full pull-modify-push cycle converts links correctly', () => {
+    // Setup: Create mock page state with multiple pages
+    // Per ADR-0024: Use PageStateCache built from frontmatter
+    const pageState = createPageStateCache({
+      'page-1': {
+        pageId: 'page-1',
+        localPath: 'home.md',
+        title: 'Home',
+      },
+      'page-2': {
+        pageId: 'page-2',
+        localPath: 'architecture/overview.md',
+        title: 'Architecture Overview',
+      },
+      'page-3': {
+        pageId: 'page-3',
+        localPath: 'architecture/database.md',
+        title: 'Database Design',
+      },
+    });
+
+    const pageLookupMap = buildPageLookupMapFromCache(pageState);
+
+    // Step 1: PULL - Convert Confluence HTML with page links to markdown
+    const confluenceHtml = `<p>Welcome to our documentation!</p><p>Check out the <ac:link><ri:page ri:content-title="Architecture Overview" ri:space-key="TEST" /><ac:plain-text-link-body><![CDATA[Architecture]]></ac:plain-text-link-body></ac:link> for design details.</p><p>Also see <ac:link><ri:page ri:content-title="Database Design" ri:space-key="TEST" /><ac:plain-text-link-body><![CDATA[Database Schema]]></ac:plain-text-link-body></ac:link>.</p>`;
+
+    const markdownConverter = new MarkdownConverter();
+    const { markdown, warnings: pullWarnings } = markdownConverter.convertPage(
+      {
+        id: 'page-1',
+        status: 'current',
+        title: 'Home',
+        spaceId: 'space-123',
+        authorId: 'user-1',
+        body: {
+          storage: {
+            value: confluenceHtml,
+            representation: 'storage',
+          },
+        },
+        version: {
+          number: 1,
+          createdAt: '2024-01-01T00:00:00Z',
+        },
+      },
+      [],
+      undefined,
+      '',
+      undefined,
+      undefined,
+      'home.md',
+      pageLookupMap,
+    );
+
+    // Verify: Links were converted to relative paths during pull
+    expect(markdown).toContain('[Architecture](./architecture/overview.md)');
+    expect(markdown).toContain('[Database Schema](./architecture/database.md)');
+    expect(markdown).not.toContain('ri:page');
+    expect(pullWarnings.length).toBe(0);
+
+    // Step 2: Simulate user modifying the markdown locally
+    // Extract just the content (without frontmatter) for the push
+    const { content: markdownContent } = parseMarkdown(markdown);
+
+    // Step 3: PUSH - Convert markdown with relative paths back to Confluence HTML
+    const htmlConverter = new HtmlConverter();
+    const { html, warnings: pushWarnings } = htmlConverter.convert(
+      markdownContent,
+      '/test/space',
+      'home.md',
+      'TEST',
+      pageLookupMap,
+    );
+
+    // Verify: Links were converted back to Confluence format during push
+    expect(html).toContain('<ac:link>');
+    expect(html).toContain('ri:page ri:content-title="Architecture Overview"');
+    expect(html).toContain('ri:space-key="TEST"');
+    expect(html).toContain('ri:page ri:content-title="Database Design"');
+    expect(html).toContain('<ac:plain-text-link-body><![CDATA[Architecture]]></ac:plain-text-link-body>');
+    expect(html).toContain('<ac:plain-text-link-body><![CDATA[Database Schema]]></ac:plain-text-link-body>');
+    expect(pushWarnings.length).toBe(0);
+
+    // Verify: Round-trip conversion preserves link semantics
+    // (The exact formatting might differ slightly, but the meaning should be the same)
+    expect(html).not.toContain('./architecture/overview.md');
+    expect(html).not.toContain('./architecture/database.md');
+  });
+
+  // TODO: Same issue as above - requires turndown enhancement
+  test.skip('handles broken links gracefully during pull and push', () => {
+    // Per ADR-0024: Use PageStateCache built from frontmatter
+    const pageState = createPageStateCache({
+      'page-1': {
+        pageId: 'page-1',
+        localPath: 'home.md',
+        title: 'Home',
+      },
+    });
+
+    const pageLookupMap = buildPageLookupMapFromCache(pageState);
+
+    // PULL: Link to non-existent page in Confluence
+    const confluenceHtml = `<p>See <ac:link><ri:page ri:content-title="Non Existent Page" ri:space-key="TEST" /><ac:plain-text-link-body><![CDATA[Non Existent]]></ac:plain-text-link-body></ac:link>.</p>`;
+
+    const markdownConverter = new MarkdownConverter();
+    const { markdown, warnings: pullWarnings } = markdownConverter.convertPage(
+      {
+        id: 'page-1',
+        status: 'current',
+        title: 'Home',
+        spaceId: 'space-123',
+        authorId: 'user-1',
+        body: {
+          storage: {
+            value: confluenceHtml,
+            representation: 'storage',
+          },
+        },
+        version: {
+          number: 1,
+          createdAt: '2024-01-01T00:00:00Z',
+        },
+      },
+      [],
+      undefined,
+      '',
+      undefined,
+      undefined,
+      'home.md',
+      pageLookupMap,
+    );
+
+    // Should preserve original content and warn
+    expect(pullWarnings.length).toBeGreaterThan(0);
+    expect(pullWarnings[0]).toContain('could not be resolved');
+    expect(markdown).not.toContain('./non-existent-page.md');
+
+    // PUSH: Link to non-existent local file
+    const localMarkdown = 'See [this page](./non-existent.md).';
+    const htmlConverter = new HtmlConverter();
+    const { html, warnings: pushWarnings } = htmlConverter.convert(
+      localMarkdown,
+      '/test/space',
+      'home.md',
+      'TEST',
+      pageLookupMap,
+    );
+
+    // Should fall back to HTML link and warn
+    expect(pushWarnings.length).toBeGreaterThan(0);
+    expect(pushWarnings[0]).toContain('could not be resolved');
+    expect(html).toContain('<a href="./non-existent.md">');
+    expect(html).not.toContain('ri:page');
+  });
+});

package/src/test/link-converter.test.ts

@@ -0,0 +1,413 @@
+import { describe, expect, test } from 'bun:test';
+import {
+  buildPageLookupMapFromCache,
+  confluenceLinkToRelativePath,
+  extractPageTitleFromLink,
+  relativePathToConfluenceLink,
+  type PageLookupMap,
+} from '../lib/markdown/link-converter.js';
+import type { PageStateCache, FullPageInfo } from '../lib/page-state.js';
+
+/**
+ * Helper to create PageStateCache from a simple record
+ * Simplifies test setup by avoiding need to create actual files
+ */
+function createPageStateCache(
+  pages: Record<string, { pageId: string; localPath: string; title: string; version?: number }>,
+): PageStateCache {
+  const pagesMap = new Map<string, FullPageInfo>();
+  const pathToPageId = new Map<string, string>();
+
+  for (const [pageId, info] of Object.entries(pages)) {
+    pagesMap.set(pageId, {
+      pageId: info.pageId,
+      localPath: info.localPath,
+      title: info.title,
+      version: info.version ?? 1,
+    });
+    pathToPageId.set(info.localPath, pageId);
+  }
+
+  return { pages: pagesMap, pathToPageId };
+}
+
+describe('buildPageLookupMapFromCache', () => {
+  test('builds lookup maps from PageStateCache', () => {
+    const pageState = createPageStateCache({
+      'page-1': {
+        pageId: 'page-1',
+        localPath: 'getting-started.md',
+        title: 'Getting Started',
+      },
+      'page-2': {
+        pageId: 'page-2',
+        localPath: 'architecture/overview.md',
+        title: 'Architecture Overview',
+      },
+    });
+
+    const lookupMap = buildPageLookupMapFromCache(pageState);
+
+    expect(lookupMap.idToPage.get('page-1')?.localPath).toBe('getting-started.md');
+    expect(lookupMap.idToPage.get('page-2')?.localPath).toBe('architecture/overview.md');
+    expect(lookupMap.titleToPage.get('Getting Started')?.pageId).toBe('page-1');
+    expect(lookupMap.titleToPage.get('Architecture Overview')?.pageId).toBe('page-2');
+    expect(lookupMap.pathToPage.get('getting-started.md')?.pageId).toBe('page-1');
+    expect(lookupMap.pathToPage.get('architecture/overview.md')?.pageId).toBe('page-2');
+  });
+
+  test('handles duplicate titles (deterministic ordering)', () => {
+    const pageState = createPageStateCache({
+      'page-2': {
+        pageId: 'page-2',
+        localPath: 'architecture/overview.md',
+        title: 'Overview',
+      },
+      'page-1': {
+        pageId: 'page-1',
+        localPath: 'overview.md',
+        title: 'Overview',
+      },
+    });
+
+    const lookupMap = buildPageLookupMapFromCache(pageState);
+
+    // Page with lexicographically smallest pageId should win (page-1 < page-2)
+    expect(lookupMap.titleToPage.get('Overview')?.pageId).toBe('page-1');
+  });
+
+  test('warns about duplicate titles when enabled', () => {
+    const pageState = createPageStateCache({
+      'page-2': {
+        pageId: 'page-2',
+        localPath: 'architecture/overview.md',
+        title: 'Overview',
+      },
+      'page-1': {
+        pageId: 'page-1',
+        localPath: 'overview.md',
+        title: 'Overview',
+      },
+    });
+
+    // Capture console.warn calls
+    const originalWarn = console.warn;
+    const warnings: string[] = [];
+    console.warn = (msg: string) => warnings.push(msg);
+
+    try {
+      buildPageLookupMapFromCache(pageState, true);
+
+      // Should have warned about duplicate
+      expect(warnings.length).toBe(1);
+      expect(warnings[0]).toContain('Duplicate page title "Overview"');
+      expect(warnings[0]).toContain('overview.md');
+      expect(warnings[0]).toContain('architecture/overview.md');
+      // Verify it indicates page-1 will be used (lexicographically smallest)
+      expect(warnings[0]).toContain('overview.md');
+    } finally {
+      console.warn = originalWarn;
+    }
+  });
+
+  test('handles empty PageStateCache', () => {
+    const pageState: PageStateCache = {
+      pages: new Map(),
+      pathToPageId: new Map(),
+    };
+
+    const lookupMap = buildPageLookupMapFromCache(pageState);
+
+    expect(lookupMap.idToPage.size).toBe(0);
+    expect(lookupMap.titleToPage.size).toBe(0);
+    expect(lookupMap.pathToPage.size).toBe(0);
+  });
+});
+
+describe('confluenceLinkToRelativePath', () => {
+  let lookupMap: PageLookupMap;
+
+  const pageState = createPageStateCache({
+    'page-1': {
+      pageId: 'page-1',
+      localPath: 'getting-started.md',
+      title: 'Getting Started',
+    },
+    'page-2': {
+      pageId: 'page-2',
+      localPath: 'architecture/overview.md',
+      title: 'Architecture Overview',
+    },
+    'page-3': {
+      pageId: 'page-3',
+      localPath: 'architecture/database.md',
+      title: 'Database Design',
+    },
+  });
+
+  test('converts Confluence link to relative path (same directory)', () => {
+    lookupMap = buildPageLookupMapFromCache(pageState);
+    const result = confluenceLinkToRelativePath('Architecture Overview', 'architecture/database.md', lookupMap);
+
+    expect(result).toBe('./overview.md');
+  });
+
+  test('converts Confluence link to relative path (parent directory)', () => {
+    lookupMap = buildPageLookupMapFromCache(pageState);
+    const result = confluenceLinkToRelativePath('Getting Started', 'architecture/database.md', lookupMap);
+
+    expect(result).toBe('../getting-started.md');
+  });
+
+  test('converts Confluence link to relative path (child directory)', () => {
+    lookupMap = buildPageLookupMapFromCache(pageState);
+    const result = confluenceLinkToRelativePath('Architecture Overview', 'getting-started.md', lookupMap);
+
+    expect(result).toBe('./architecture/overview.md');
+  });
+
+  test('returns null for non-existent page', () => {
+    lookupMap = buildPageLookupMapFromCache(pageState);
+    const result = confluenceLinkToRelativePath('Non Existent Page', 'getting-started.md', lookupMap);
+
+    expect(result).toBeNull();
+  });
+
+  test('handles paths that need ./ prefix', () => {
+    lookupMap = buildPageLookupMapFromCache(pageState);
+    const result = confluenceLinkToRelativePath('Database Design', 'architecture/overview.md', lookupMap);
+
+    expect(result).toBe('./database.md');
+  });
+});
+
+describe('extractPageTitleFromLink', () => {
+  test('extracts title from ri:page element', () => {
+    const html = '<ri:page ri:content-title="Getting Started" />';
+    const title = extractPageTitleFromLink(html);
+
+    expect(title).toBe('Getting Started');
+  });
+
+  test('extracts title from ac:link element', () => {
+    const html = '<ac:link><ri:page ri:content-title="Architecture Overview" /></ac:link>';
+    const title = extractPageTitleFromLink(html);
+
+    expect(title).toBe('Architecture Overview');
+  });
+
+  test('handles double quotes', () => {
+    const html = '<ri:page ri:content-title="Test Page" />';
+    const title = extractPageTitleFromLink(html);
+
+    expect(title).toBe('Test Page');
+  });
+
+  test('handles single quotes', () => {
+    const html = "<ri:page ri:content-title='Test Page' />";
+    const title = extractPageTitleFromLink(html);
+
+    expect(title).toBe('Test Page');
+  });
+
+  test('returns null if no title found', () => {
+    const html = '<ac:link></ac:link>';
+    const title = extractPageTitleFromLink(html);
+
+    expect(title).toBeNull();
+  });
+
+  test('decodes HTML entities in titles', () => {
+    const html = '<ri:page ri:content-title="Page with &amp; ampersand" />';
+    const title = extractPageTitleFromLink(html);
+
+    // HTML entities should be decoded
+    expect(title).toBe('Page with & ampersand');
+  });
+
+  test('decodes angle brackets in titles', () => {
+    const html = '<ri:page ri:content-title="Page &lt;with&gt; brackets" />';
+    const title = extractPageTitleFromLink(html);
+
+    expect(title).toBe('Page <with> brackets');
+  });
+
+  test('decodes quotes in titles', () => {
+    const html = '<ri:page ri:content-title="Page with &quot;quotes&quot;" />';
+    const title = extractPageTitleFromLink(html);
+
+    expect(title).toBe('Page with "quotes"');
+  });
+});
+
+describe('relativePathToConfluenceLink', () => {
+  let lookupMap: PageLookupMap;
+
+  const pageState = createPageStateCache({
+    'page-1': {
+      pageId: 'page-1',
+      localPath: 'getting-started.md',
+      title: 'Getting Started',
+    },
+    'page-2': {
+      pageId: 'page-2',
+      localPath: 'architecture/overview.md',
+      title: 'Architecture Overview',
+    },
+    'page-3': {
+      pageId: 'page-3',
+      localPath: 'architecture/database.md',
+      title: 'Database Design',
+    },
+  });
+
+  test('converts relative path to Confluence link (same directory)', () => {
+    lookupMap = buildPageLookupMapFromCache(pageState);
+    const result = relativePathToConfluenceLink('./overview.md', 'architecture/database.md', '/test/space', lookupMap);
+
+    expect(result).not.toBeNull();
+    expect(result?.title).toBe('Architecture Overview');
+    expect(result?.pageId).toBe('page-2');
+  });
+
+  test('converts relative path to Confluence link (parent directory)', () => {
+    lookupMap = buildPageLookupMapFromCache(pageState);
+    const result = relativePathToConfluenceLink(
+      '../getting-started.md',
+      'architecture/database.md',
+      '/test/space',
+      lookupMap,
+    );
+
+    expect(result).not.toBeNull();
+    expect(result?.title).toBe('Getting Started');
+    expect(result?.pageId).toBe('page-1');
+  });
+
+  test('converts relative path to Confluence link (child directory)', () => {
+    lookupMap = buildPageLookupMapFromCache(pageState);
+    const result = relativePathToConfluenceLink(
+      './architecture/overview.md',
+      'getting-started.md',
+      '/test/space',
+      lookupMap,
+    );
+
+    expect(result).not.toBeNull();
+    expect(result?.title).toBe('Architecture Overview');
+    expect(result?.pageId).toBe('page-2');
+  });
+
+  test('returns null for non-existent file', () => {
+    lookupMap = buildPageLookupMapFromCache(pageState);
+    const result = relativePathToConfluenceLink('./non-existent.md', 'getting-started.md', '/test/space', lookupMap);
+
+    expect(result).toBeNull();
+  });
+
+  test('handles paths without ./ prefix', () => {
+    lookupMap = buildPageLookupMapFromCache(pageState);
+    const result = relativePathToConfluenceLink('database.md', 'architecture/overview.md', '/test/space', lookupMap);
+
+    expect(result).not.toBeNull();
+    expect(result?.title).toBe('Database Design');
+    expect(result?.pageId).toBe('page-3');
+  });
+
+  test('handles deeply nested paths', () => {
+    const deepPageState = createPageStateCache({
+      'page-deep': {
+        pageId: 'page-deep',
+        localPath: 'a/b/c/d/e/f/g/h/page.md',
+        title: 'Deep Page',
+      },
+    });
+
+    lookupMap = buildPageLookupMapFromCache(deepPageState);
+    const result = relativePathToConfluenceLink('./a/b/c/d/e/f/g/h/page.md', 'home.md', '/test/space', lookupMap);
+
+    expect(result).not.toBeNull();
+    expect(result?.title).toBe('Deep Page');
+    expect(result?.pageId).toBe('page-deep');
+  });
+});
+
+describe('batch config propagation', () => {
+  test('in-memory PageStateCache updates allow subsequent link resolution', () => {
+    // This test verifies the fix for batch push link resolution
+    // When pushing multiple files, the first file's page info should be available
+    // for link resolution in subsequent files
+
+    // Start with an empty PageStateCache (simulating start of batch push)
+    const pageState: PageStateCache = {
+      pages: new Map(),
+      pathToPageId: new Map(),
+    };
+
+    // At this point, links to page-a.md cannot be resolved
+    let lookupMap = buildPageLookupMapFromCache(pageState);
+    let result = relativePathToConfluenceLink('./page-a.md', 'page-b.md', '/test/space', lookupMap);
+    expect(result).toBeNull();
+
+    // Simulate pushing page-a.md - this updates the in-memory PageStateCache
+    const pageAInfo: FullPageInfo = {
+      pageId: 'page-a-id',
+      localPath: 'page-a.md',
+      title: 'Page A',
+      version: 1,
+    };
+    pageState.pages.set('page-a-id', pageAInfo);
+    pageState.pathToPageId.set('page-a.md', 'page-a-id');
+
+    // Now rebuild the lookup map with the updated PageStateCache
+    // This is what happens during batch push - the updated state is passed to the next file
+    lookupMap = buildPageLookupMapFromCache(pageState);
+
+    // Now links to page-a.md CAN be resolved
+    result = relativePathToConfluenceLink('./page-a.md', 'page-b.md', '/test/space', lookupMap);
+    expect(result).not.toBeNull();
+    expect(result?.pageId).toBe('page-a-id');
+    expect(result?.title).toBe('Page A');
+  });
+
+  test('multiple pages pushed in sequence are all resolvable', () => {
+    // Simulates pushing three files where each links to the previous
+    const pageState: PageStateCache = {
+      pages: new Map(),
+      pathToPageId: new Map(),
+    };
+
+    // Push page-a.md
+    const pageAInfo: FullPageInfo = {
+      pageId: 'page-a-id',
+      localPath: 'page-a.md',
+      title: 'Page A',
+      version: 1,
+    };
+    pageState.pages.set('page-a-id', pageAInfo);
+    pageState.pathToPageId.set('page-a.md', 'page-a-id');
+
+    // Push page-b.md (can now link to page-a)
+    let lookupMap = buildPageLookupMapFromCache(pageState);
+    let result = relativePathToConfluenceLink('./page-a.md', 'page-b.md', '/test/space', lookupMap);
+    expect(result?.pageId).toBe('page-a-id');
+
+    const pageBInfo: FullPageInfo = {
+      pageId: 'page-b-id',
+      localPath: 'page-b.md',
+      title: 'Page B',
+      version: 1,
+    };
+    pageState.pages.set('page-b-id', pageBInfo);
+    pageState.pathToPageId.set('page-b.md', 'page-b-id');
+
+    // Push page-c.md (can now link to both page-a and page-b)
+    lookupMap = buildPageLookupMapFromCache(pageState);
+
+    result = relativePathToConfluenceLink('./page-a.md', 'page-c.md', '/test/space', lookupMap);
+    expect(result?.pageId).toBe('page-a-id');
+
+    result = relativePathToConfluenceLink('./page-b.md', 'page-c.md', '/test/space', lookupMap);
+    expect(result?.pageId).toBe('page-b-id');
+  });
+});