@aaronshaf/confluence-cli 0.1.15

package/src/test/sync-engine.test.ts

@@ -0,0 +1,486 @@
+import { afterEach, beforeEach, describe, expect, test } from 'bun:test';
+import { existsSync, mkdirSync, rmSync, writeFileSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { http, HttpResponse } from 'msw';
+import { SyncEngine } from '../lib/sync/sync-engine.js';
+import { writeSpaceConfig, type SpaceConfigWithState } from '../lib/space-config.js';
+import { server } from './setup-msw.js';
+import { createValidPage, createValidSpace } from './msw-schema-validation.js';
+import { parseMarkdown } from '../lib/markdown/frontmatter.js';
+
+const testConfig = {
+  confluenceUrl: 'https://test.atlassian.net',
+  email: 'test@example.com',
+  apiToken: 'test-token',
+};
+
+describe('SyncEngine', () => {
+  let testDir: string;
+
+  beforeEach(() => {
+    testDir = join(tmpdir(), `cn-test-${Date.now()}`);
+    mkdirSync(testDir, { recursive: true });
+  });
+
+  afterEach(() => {
+    if (existsSync(testDir)) {
+      rmSync(testDir, { recursive: true });
+    }
+  });
+
+  describe('initSync', () => {
+    test('initializes sync for a space', async () => {
+      server.use(
+        http.get('*/wiki/api/v2/spaces', ({ request }) => {
+          const url = new URL(request.url);
+          const keys = url.searchParams.get('keys');
+          if (keys === 'TEST') {
+            return HttpResponse.json({
+              results: [createValidSpace({ id: 'space-123', key: 'TEST', name: 'Test Space' })],
+            });
+          }
+          return HttpResponse.json({ results: [] });
+        }),
+      );
+
+      const engine = new SyncEngine(testConfig);
+      const config = await engine.initSync(testDir, 'TEST');
+
+      expect(config.spaceKey).toBe('TEST');
+      expect(config.spaceId).toBe('space-123');
+      expect(config.spaceName).toBe('Test Space');
+
+      // Check that .confluence.json was created
+      const configPath = join(testDir, '.confluence.json');
+      expect(existsSync(configPath)).toBe(true);
+    });
+  });
+
+  describe('fetchPageTree', () => {
+    test('fetches all pages in a space', async () => {
+      const engine = new SyncEngine(testConfig);
+      const pages = await engine.fetchPageTree('space-123');
+
+      expect(pages).toBeArray();
+    });
+  });
+
+  describe('buildPageTree', () => {
+    test('builds tree from flat pages', () => {
+      const pages = [
+        { id: 'page-1', title: 'Home', spaceId: 'space-123', status: 'current', parentId: null },
+        { id: 'page-2', title: 'Getting Started', spaceId: 'space-123', status: 'current', parentId: 'page-1' },
+        { id: 'page-3', title: 'API Reference', spaceId: 'space-123', status: 'current', parentId: 'page-1' },
+        { id: 'page-4', title: 'Installation', spaceId: 'space-123', status: 'current', parentId: 'page-2' },
+      ];
+
+      const engine = new SyncEngine(testConfig);
+      const tree = engine.buildPageTree(pages);
+
+      expect(tree).toHaveLength(1);
+      expect(tree[0].page.title).toBe('Home');
+      expect(tree[0].children).toHaveLength(2);
+    });
+
+    test('handles orphan pages', () => {
+      const pages = [
+        { id: 'page-1', title: 'Page 1', spaceId: 'space-123', status: 'current', parentId: 'missing-parent' },
+        { id: 'page-2', title: 'Page 2', spaceId: 'space-123', status: 'current', parentId: null },
+      ];
+
+      const engine = new SyncEngine(testConfig);
+      const tree = engine.buildPageTree(pages);
+
+      expect(tree).toHaveLength(2);
+    });
+  });
+
+  describe('computeDiff', () => {
+    test('detects added pages', () => {
+      const remotePages = [
+        { id: 'page-1', title: 'Page 1', spaceId: 'space-123', status: 'current', version: { number: 1 } },
+        { id: 'page-2', title: 'Page 2', spaceId: 'space-123', status: 'current', version: { number: 1 } },
+      ];
+
+      const localConfig: SpaceConfigWithState = {
+        spaceKey: 'TEST',
+        spaceId: 'space-123',
+        spaceName: 'Test Space',
+        pages: {},
+      };
+
+      const engine = new SyncEngine(testConfig);
+      const diff = engine.computeDiff(remotePages, localConfig);
+
+      expect(diff.added).toHaveLength(2);
+      expect(diff.modified).toHaveLength(0);
+      expect(diff.deleted).toHaveLength(0);
+    });
+
+    test('detects modified pages', () => {
+      const remotePages = [
+        { id: 'page-1', title: 'Page 1', spaceId: 'space-123', status: 'current', version: { number: 2 } },
+      ];
+
+      // Per ADR-0024: pages is now Record<string, string> (pageId -> localPath)
+      const localConfig: SpaceConfigWithState = {
+        spaceKey: 'TEST',
+        spaceId: 'space-123',
+        spaceName: 'Test Space',
+        pages: {
+          'page-1': 'page-1.md',
+        },
+      };
+
+      const engine = new SyncEngine(testConfig);
+      // Without PageStateCache, local version defaults to 0, so remote v2 > local v0 -> modified
+      const diff = engine.computeDiff(remotePages, localConfig);
+
+      expect(diff.added).toHaveLength(0);
+      expect(diff.modified).toHaveLength(1);
+      expect(diff.deleted).toHaveLength(0);
+    });
+
+    test('detects deleted pages', () => {
+      const remotePages: any[] = [];
+
+      // Per ADR-0024: pages is now Record<string, string> (pageId -> localPath)
+      const localConfig: SpaceConfigWithState = {
+        spaceKey: 'TEST',
+        spaceId: 'space-123',
+        spaceName: 'Test Space',
+        pages: {
+          'page-1': 'page-1.md',
+        },
+      };
+
+      const engine = new SyncEngine(testConfig);
+      const diff = engine.computeDiff(remotePages, localConfig);
+
+      expect(diff.added).toHaveLength(0);
+      expect(diff.modified).toHaveLength(0);
+      expect(diff.deleted).toHaveLength(1);
+    });
+
+    test('handles null localConfig', () => {
+      const remotePages = [
+        { id: 'page-1', title: 'Page 1', spaceId: 'space-123', status: 'current', version: { number: 1 } },
+      ];
+
+      const engine = new SyncEngine(testConfig);
+      const diff = engine.computeDiff(remotePages, null);
+
+      expect(diff.added).toHaveLength(1);
+      expect(diff.modified).toHaveLength(0);
+      expect(diff.deleted).toHaveLength(0);
+    });
+
+    test('filters out archived pages from remote', () => {
+      const remotePages = [
+        { id: 'page-1', title: 'Current Page', spaceId: 'space-123', status: 'current', version: { number: 1 } },
+        { id: 'page-2', title: 'Archived Page', spaceId: 'space-123', status: 'archived', version: { number: 1 } },
+        { id: 'page-3', title: 'Another Current', spaceId: 'space-123', status: 'current', version: { number: 1 } },
+        { id: 'page-4', title: 'Draft Page', spaceId: 'space-123', status: 'draft', version: { number: 1 } },
+        { id: 'page-5', title: 'Trashed Page', spaceId: 'space-123', status: 'trashed', version: { number: 1 } },
+      ];
+
+      const localConfig: SpaceConfigWithState = {
+        spaceKey: 'TEST',
+        spaceId: 'space-123',
+        spaceName: 'Test Space',
+        pages: {},
+      };
+
+      const engine = new SyncEngine(testConfig);
+      const diff = engine.computeDiff(remotePages, localConfig);
+
+      // Only the 2 current pages should be added (filters out archived, draft, and trashed)
+      expect(diff.added).toHaveLength(2);
+      expect(diff.added[0].pageId).toBe('page-1');
+      expect(diff.added[1].pageId).toBe('page-3');
+      expect(diff.modified).toHaveLength(0);
+      expect(diff.deleted).toHaveLength(0);
+    });
+
+    test('treats locally-synced archived pages as deleted', () => {
+      const remotePages = [
+        { id: 'page-1', title: 'Current Page', spaceId: 'space-123', status: 'current', version: { number: 1 } },
+        { id: 'page-2', title: 'Archived Page', spaceId: 'space-123', status: 'archived', version: { number: 1 } },
+      ];
+
+      const localConfig: SpaceConfigWithState = {
+        spaceKey: 'TEST',
+        spaceId: 'space-123',
+        spaceName: 'Test Space',
+        pages: {
+          'page-1': 'page-1.md',
+          'page-2': 'page-2.md', // This page is archived remotely
+        },
+      };
+
+      // Provide PageStateCache so page-1 is not seen as modified
+      const pageState = {
+        pages: new Map([
+          ['page-1', { pageId: 'page-1', localPath: 'page-1.md', title: 'Current Page', version: 1 }],
+          ['page-2', { pageId: 'page-2', localPath: 'page-2.md', title: 'Archived Page', version: 1 }],
+        ]),
+        pathToPageId: new Map([
+          ['page-1.md', 'page-1'],
+          ['page-2.md', 'page-2'],
+        ]),
+      };
+
+      const engine = new SyncEngine(testConfig);
+      const diff = engine.computeDiff(remotePages, localConfig, pageState);
+
+      expect(diff.added).toHaveLength(0);
+      expect(diff.modified).toHaveLength(0);
+      // page-2 should be detected as deleted because it's archived
+      expect(diff.deleted).toHaveLength(1);
+      expect(diff.deleted[0].pageId).toBe('page-2');
+    });
+  });
+
+  describe('sync', () => {
+    test('fails without space configuration', async () => {
+      const engine = new SyncEngine(testConfig);
+      const result = await engine.sync(testDir);
+
+      expect(result.success).toBe(false);
+      expect(result.errors).toHaveLength(1);
+      expect(result.errors[0]).toContain('No space configuration found');
+    });
+
+    test('performs dry run without changes', async () => {
+      // Set up space config
+      const spaceConfig: SpaceConfigWithState = {
+        spaceKey: 'TEST',
+        spaceId: 'space-123',
+        spaceName: 'Test Space',
+        pages: {},
+      };
+      writeSpaceConfig(testDir, spaceConfig);
+
+      const engine = new SyncEngine(testConfig);
+      const result = await engine.sync(testDir, { dryRun: true });
+
+      expect(result.success).toBe(true);
+      // In dry run, no files should be created
+      const files = existsSync(join(testDir, 'home.md'));
+      expect(files).toBe(false);
+    });
+
+    test('syncs new pages', async () => {
+      // Set up mocks for pages
+      server.use(
+        http.get('*/wiki/api/v2/spaces/:spaceId/pages', () => {
+          return HttpResponse.json({
+            results: [
+              createValidPage({
+                id: 'page-1',
+                title: 'Home',
+                spaceId: 'space-123',
+                body: '<p>Welcome!</p>',
+              }),
+            ],
+          });
+        }),
+        http.get('*/wiki/api/v2/pages/:pageId', ({ params }) => {
+          return HttpResponse.json(
+            createValidPage({
+              id: params.pageId as string,
+              title: 'Home',
+              spaceId: 'space-123',
+              body: '<p>Welcome!</p>',
+            }),
+          );
+        }),
+      );
+
+      // Set up space config
+      const spaceConfig: SpaceConfigWithState = {
+        spaceKey: 'TEST',
+        spaceId: 'space-123',
+        spaceName: 'Test Space',
+        pages: {},
+      };
+      writeSpaceConfig(testDir, spaceConfig);
+
+      const engine = new SyncEngine(testConfig);
+      const result = await engine.sync(testDir);
+
+      expect(result.success).toBe(true);
+      expect(result.changes.added).toHaveLength(1);
+    });
+
+    test('skips pages with reserved filenames during sync', async () => {
+      // Set up mocks for pages - include a page titled "Claude" which would generate claude.md
+      server.use(
+        http.get('*/wiki/api/v2/spaces/:spaceId/pages', () => {
+          return HttpResponse.json({
+            results: [
+              createValidPage({
+                id: 'page-1',
+                title: 'Home',
+                spaceId: 'space-123',
+                body: '<p>Welcome!</p>',
+              }),
+              createValidPage({
+                id: 'page-2',
+                title: 'Claude',
+                spaceId: 'space-123',
+                parentId: 'page-1',
+                body: '<p>This should be skipped</p>',
+              }),
+              createValidPage({
+                id: 'page-3',
+                title: 'Agents',
+                spaceId: 'space-123',
+                parentId: 'page-1',
+                body: '<p>This should also be skipped</p>',
+              }),
+            ],
+          });
+        }),
+        http.get('*/wiki/api/v2/pages/:pageId', ({ params }) => {
+          const pageId = params.pageId as string;
+          const titles: Record<string, string> = {
+            'page-1': 'Home',
+            'page-2': 'Claude',
+            'page-3': 'Agents',
+          };
+          return HttpResponse.json(
+            createValidPage({
+              id: pageId,
+              title: titles[pageId] || 'Unknown',
+              spaceId: 'space-123',
+              parentId: pageId === 'page-1' ? undefined : 'page-1',
+              body: '<p>Content</p>',
+            }),
+          );
+        }),
+      );
+
+      // Set up space config
+      const spaceConfig: SpaceConfigWithState = {
+        spaceKey: 'TEST',
+        spaceId: 'space-123',
+        spaceName: 'Test Space',
+        pages: {},
+      };
+      writeSpaceConfig(testDir, spaceConfig);
+
+      const engine = new SyncEngine(testConfig);
+      const result = await engine.sync(testDir);
+
+      expect(result.success).toBe(true);
+      // 3 pages were added to diff, but 2 should be skipped
+      expect(result.changes.added).toHaveLength(3);
+      // Only README.md (home page) should exist, not claude.md or agents.md
+      expect(existsSync(join(testDir, 'README.md'))).toBe(true);
+      expect(existsSync(join(testDir, 'claude.md'))).toBe(false);
+      expect(existsSync(join(testDir, 'agents.md'))).toBe(false);
+      // Should have warnings about skipped pages (check for "reserved filename" in the message)
+      expect(result.warnings.some((w) => w.includes('reserved filename') && w.includes('Claude'))).toBe(true);
+      expect(result.warnings.some((w) => w.includes('reserved filename') && w.includes('Agents'))).toBe(true);
+    });
+
+    test('includes child_count in frontmatter for synced pages', async () => {
+      // Set up page hierarchy:
+      // Root (page-root) - 2 children
+      //   ├─ Child 1 (page-child1) - 0 children
+      //   └─ Child 2 (page-child2) - 1 child
+      //       └─ Grandchild (page-grandchild) - 0 children
+      server.use(
+        http.get('*/wiki/api/v2/spaces/:spaceId/pages', () => {
+          return HttpResponse.json({
+            results: [
+              createValidPage({
+                id: 'page-root',
+                title: 'Root Page',
+                spaceId: 'space-123',
+                body: '<p>Root content</p>',
+              }),
+              createValidPage({
+                id: 'page-child1',
+                title: 'Child 1',
+                spaceId: 'space-123',
+                parentId: 'page-root',
+                body: '<p>Child 1 content</p>',
+              }),
+              createValidPage({
+                id: 'page-child2',
+                title: 'Child 2',
+                spaceId: 'space-123',
+                parentId: 'page-root',
+                body: '<p>Child 2 content</p>',
+              }),
+              createValidPage({
+                id: 'page-grandchild',
+                title: 'Grandchild',
+                spaceId: 'space-123',
+                parentId: 'page-child2',
+                body: '<p>Grandchild content</p>',
+              }),
+            ],
+          });
+        }),
+        http.get('*/wiki/api/v2/pages/:pageId', ({ params }) => {
+          const pageId = params.pageId as string;
+          const pageData: Record<string, { title: string; parentId?: string }> = {
+            'page-root': { title: 'Root Page' },
+            'page-child1': { title: 'Child 1', parentId: 'page-root' },
+            'page-child2': { title: 'Child 2', parentId: 'page-root' },
+            'page-grandchild': { title: 'Grandchild', parentId: 'page-child2' },
+          };
+          const data = pageData[pageId] || { title: 'Unknown' };
+          return HttpResponse.json(
+            createValidPage({
+              id: pageId,
+              title: data.title,
+              spaceId: 'space-123',
+              parentId: data.parentId,
+              body: `<p>${data.title} content</p>`,
+            }),
+          );
+        }),
+      );
+
+      // Set up space config
+      const spaceConfig: SpaceConfigWithState = {
+        spaceKey: 'TEST',
+        spaceId: 'space-123',
+        spaceName: 'Test Space',
+        pages: {},
+      };
+      writeSpaceConfig(testDir, spaceConfig);
+
+      const engine = new SyncEngine(testConfig);
+      const result = await engine.sync(testDir);
+
+      expect(result.success).toBe(true);
+      expect(result.changes.added).toHaveLength(4);
+
+      // Verify child_count in synced files
+      const rootContent = readFileSync(join(testDir, 'README.md'), 'utf-8');
+      const child1Content = readFileSync(join(testDir, 'child-1.md'), 'utf-8');
+      const child2Content = readFileSync(join(testDir, 'child-2/README.md'), 'utf-8');
+      const grandchildContent = readFileSync(join(testDir, 'child-2/grandchild.md'), 'utf-8');
+
+      const rootFrontmatter = parseMarkdown(rootContent).frontmatter;
+      const child1Frontmatter = parseMarkdown(child1Content).frontmatter;
+      const child2Frontmatter = parseMarkdown(child2Content).frontmatter;
+      const grandchildFrontmatter = parseMarkdown(grandchildContent).frontmatter;
+
+      // Root has 2 direct children
+      expect(rootFrontmatter.child_count).toBe(2);
+      // Child 1 has 0 children (leaf page)
+      expect(child1Frontmatter.child_count).toBe(0);
+      // Child 2 has 1 child
+      expect(child2Frontmatter.child_count).toBe(1);
+      // Grandchild has 0 children (leaf page)
+      expect(grandchildFrontmatter.child_count).toBe(0);
+    });
+  });
+});

package/src/types/turndown-plugin-gfm.d.ts

@@ -0,0 +1,9 @@
+declare module 'turndown-plugin-gfm' {
+  import type TurndownService from 'turndown';
+
+  export function gfm(turndownService: TurndownService): void;
+  export function tables(turndownService: TurndownService): void;
+  export function strikethrough(turndownService: TurndownService): void;
+  export function taskListItems(turndownService: TurndownService): void;
+  export function highlightedCodeBlock(turndownService: TurndownService): void;
+}