@aaronshaf/confluence-cli 0.1.15 → 1.0.1

package/src/test/folder-command.test.ts

@@ -0,0 +1,182 @@
+import { describe, expect, test } from 'bun:test';
+import { HttpResponse, http } from 'msw';
+import { ConfluenceClient } from '../lib/confluence-client/client.js';
+import { server } from './setup-msw.js';
+import { createValidFolder, createValidSpace } from './msw-schema-validation.js';
+
+const testConfig = {
+  confluenceUrl: 'https://test.atlassian.net',
+  email: 'test@example.com',
+  apiToken: 'test-token',
+};
+
+describe('cn folder - API layer', () => {
+  describe('createFolder', () => {
+    test('creates a folder with spaceId resolved from getSpaceByKey', async () => {
+      let capturedBody: unknown;
+
+      server.use(
+        http.get('*/wiki/api/v2/spaces', ({ request }) => {
+          const url = new URL(request.url);
+          const keys = url.searchParams.get('keys');
+          return HttpResponse.json({ results: [createValidSpace({ id: 'space-456', key: keys ?? 'DOCS' })] });
+        }),
+        http.post('*/wiki/api/v2/folders', async ({ request }) => {
+          capturedBody = await request.json();
+          return HttpResponse.json(createValidFolder({ id: 'folder-new', title: 'My Folder' }));
+        }),
+      );
+
+      const client = new ConfluenceClient(testConfig);
+      const space = await client.getSpaceByKey('DOCS');
+      const folder = await client.createFolder({ spaceId: space.id, title: 'My Folder' });
+
+      expect(space.id).toBe('space-456');
+      expect(folder.id).toBe('folder-new');
+      expect(folder.title).toBe('My Folder');
+      expect((capturedBody as { spaceId: string }).spaceId).toBe('space-456');
+    });
+
+    test('creates a folder with a parentId', async () => {
+      let capturedBody: unknown;
+
+      server.use(
+        http.post('*/wiki/api/v2/folders', async ({ request }) => {
+          capturedBody = await request.json();
+          return HttpResponse.json(
+            createValidFolder({ id: 'folder-child', title: 'Child Folder', parentId: 'folder-parent' }),
+          );
+        }),
+      );
+
+      const client = new ConfluenceClient(testConfig);
+      await client.createFolder({ spaceId: 'space-123', title: 'Child Folder', parentId: 'folder-parent' });
+
+      expect((capturedBody as { parentId: string }).parentId).toBe('folder-parent');
+    });
+  });
+
+  describe('deleteFolder', () => {
+    test('deletes a folder by ID', async () => {
+      let deletedId = '';
+
+      server.use(
+        http.delete('*/wiki/api/v2/folders/:folderId', ({ params }) => {
+          deletedId = params.folderId as string;
+          return new HttpResponse(null, { status: 204 });
+        }),
+      );
+
+      const client = new ConfluenceClient(testConfig);
+      await client.deleteFolder('folder-123');
+
+      expect(deletedId).toBe('folder-123');
+    });
+
+    test('throws FolderNotFoundError for 404', async () => {
+      server.use(
+        http.delete('*/wiki/api/v2/folders/:folderId', () => {
+          return HttpResponse.json({ message: 'Not found' }, { status: 404 });
+        }),
+      );
+
+      const client = new ConfluenceClient(testConfig);
+      await expect(client.deleteFolder('nonexistent')).rejects.toThrow();
+    });
+  });
+
+  describe('folder list pagination', () => {
+    test('fetches a single page when total fits in one request', async () => {
+      server.use(
+        http.get('*/wiki/rest/api/search', ({ request }) => {
+          const url = new URL(request.url);
+          const start = Number(url.searchParams.get('start') ?? 0);
+          if (start === 0) {
+            return HttpResponse.json({
+              results: [
+                { content: { id: 'f1', type: 'folder', title: 'Folder 1' } },
+                { content: { id: 'f2', type: 'folder', title: 'Folder 2' } },
+              ],
+              totalSize: 2,
+            });
+          }
+          return HttpResponse.json({ results: [], totalSize: 2 });
+        }),
+      );
+
+      const client = new ConfluenceClient(testConfig);
+      const page1 = await client.search('type=folder AND space="TEST"', 100, 0);
+      expect(page1.results).toHaveLength(2);
+      expect(page1.totalSize).toBe(2);
+    });
+
+    test('paginates when totalSize exceeds page size', async () => {
+      const allFolders = Array.from({ length: 150 }, (_, i) => ({
+        content: { id: `f${i}`, type: 'folder', title: `Folder ${i}` },
+      }));
+
+      server.use(
+        http.get('*/wiki/rest/api/search', ({ request }) => {
+          const url = new URL(request.url);
+          const start = Number(url.searchParams.get('start') ?? 0);
+          const limit = Number(url.searchParams.get('limit') ?? 10);
+          const slice = allFolders.slice(start, start + limit);
+          return HttpResponse.json({ results: slice, totalSize: 150 });
+        }),
+      );
+
+      const client = new ConfluenceClient(testConfig);
+      const collected = [];
+      let start = 0;
+      const PAGE_SIZE = 100;
+
+      const first = await client.search('type=folder AND space="TEST"', PAGE_SIZE, start);
+      collected.push(...first.results);
+      const total = first.totalSize ?? first.results.length;
+
+      while (collected.length < total) {
+        start += PAGE_SIZE;
+        const page = await client.search('type=folder AND space="TEST"', PAGE_SIZE, start);
+        if (page.results.length === 0) break;
+        collected.push(...page.results);
+      }
+
+      expect(collected).toHaveLength(150);
+    });
+  });
+
+  describe('getPositionals (arg parsing)', () => {
+    // Test the arg parsing logic directly via the folderCommand behavior
+    test('search passes start param in URL', async () => {
+      const capturedUrls: string[] = [];
+
+      server.use(
+        http.get('*/wiki/rest/api/search', ({ request }) => {
+          capturedUrls.push(request.url);
+          return HttpResponse.json({ results: [], totalSize: 0 });
+        }),
+      );
+
+      const client = new ConfluenceClient(testConfig);
+      await client.search('type=folder', 100, 42);
+
+      expect(capturedUrls[0]).toContain('start=42');
+    });
+
+    test('search passes limit param in URL', async () => {
+      const capturedUrls: string[] = [];
+
+      server.use(
+        http.get('*/wiki/rest/api/search', ({ request }) => {
+          capturedUrls.push(request.url);
+          return HttpResponse.json({ results: [], totalSize: 0 });
+        }),
+      );
+
+      const client = new ConfluenceClient(testConfig);
+      await client.search('type=folder', 50, 0);
+
+      expect(capturedUrls[0]).toContain('limit=50');
+    });
+  });
+});

package/src/test/mocks/handlers.ts

@@ -26,6 +26,18 @@ import {
  * Individual tests should override these with server.use() for specific test scenarios.
  */
 export const handlers = [
+  // Confluence v1 spaces mock (offset-based pagination)
+  http.get('*/wiki/rest/api/space', ({ request }) => {
+    const url = new URL(request.url);
+    const limit = Number(url.searchParams.get('limit') ?? 25);
+    const start = Number(url.searchParams.get('start') ?? 0);
+    const spaces = [
+      { id: 1, key: 'TEST', name: 'Test Space', type: 'global' },
+      { id: 2, key: 'DOCS', name: 'Documentation', type: 'global' },
+    ].slice(start, start + limit);
+    return HttpResponse.json({ results: spaces, start, limit, size: spaces.length });
+  }),
+
   // Confluence spaces mock
   http.get('*/wiki/api/v2/spaces', ({ request }) => {
     const url = new URL(request.url);

package/src/test/spaces.test.ts

@@ -42,7 +42,7 @@ describe('ConfluenceClient - spaces', () => {
 
   test('throws on 401', async () => {
     server.use(
-      http.get('*/wiki/api/v2/spaces', () => {
+      http.get('*/wiki/rest/api/space', () => {
         return HttpResponse.json({ error: 'Unauthorized' }, { status: 401 });
       }),
     );

package/src/test/update.test.ts

@@ -0,0 +1,115 @@
+import { describe, expect, test } from 'bun:test';
+import { HttpResponse, http } from 'msw';
+import { ConfluenceClient } from '../lib/confluence-client/client.js';
+import { server } from './setup-msw.js';
+import { createValidPage } from './msw-schema-validation.js';
+import { findPositional } from '../cli/utils/args.js';
+import { isValidFormat, VALID_FORMATS } from '../cli/utils/stdin.js';
+
+const testConfig = {
+  confluenceUrl: 'https://test.atlassian.net',
+  email: 'test@example.com',
+  apiToken: 'test-token',
+};
+
+describe('ConfluenceClient - updatePage', () => {
+  test('updates page successfully', async () => {
+    server.use(
+      http.put('*/wiki/api/v2/pages/:pageId', async ({ request, params }) => {
+        const body = (await request.json()) as { title: string; body: { value: string } };
+        const page = createValidPage({
+          id: params.pageId as string,
+          title: body.title,
+          version: 2,
+        });
+        return HttpResponse.json(page);
+      }),
+    );
+
+    const client = new ConfluenceClient(testConfig);
+    const result = await client.updatePage({
+      id: 'page-123',
+      status: 'current',
+      title: 'Updated Title',
+      body: { representation: 'storage', value: '<p>New content</p>' },
+      version: { number: 2 },
+    });
+
+    expect(result.id).toBe('page-123');
+  });
+
+  test('fetches page without body when includeBody=false', async () => {
+    let requestUrl = '';
+    server.use(
+      http.get('*/wiki/api/v2/pages/:pageId', ({ request }) => {
+        requestUrl = request.url;
+        const page = createValidPage({ id: 'page-123', version: 3 });
+        return HttpResponse.json(page);
+      }),
+    );
+
+    const client = new ConfluenceClient(testConfig);
+    await client.getPage('page-123', false);
+    expect(requestUrl).not.toContain('body-format');
+  });
+
+  test('throws on 404', async () => {
+    server.use(
+      http.put('*/wiki/api/v2/pages/:pageId', () => {
+        return HttpResponse.json({ message: 'Not found' }, { status: 404 });
+      }),
+    );
+
+    const client = new ConfluenceClient(testConfig);
+    await expect(
+      client.updatePage({
+        id: 'nonexistent',
+        status: 'current',
+        title: 'Title',
+        body: { representation: 'storage', value: '<p>x</p>' },
+        version: { number: 2 },
+      }),
+    ).rejects.toThrow();
+  });
+});
+
+describe('format validation', () => {
+  test('accepts valid formats', () => {
+    for (const fmt of VALID_FORMATS) {
+      expect(isValidFormat(fmt)).toBe(true);
+    }
+  });
+
+  test('rejects markdown', () => {
+    expect(isValidFormat('markdown')).toBe(false);
+  });
+
+  test('rejects unknown format', () => {
+    expect(isValidFormat('html')).toBe(false);
+  });
+});
+
+describe('findPositional', () => {
+  test('finds simple positional arg', () => {
+    expect(findPositional(['123456'], ['--format', '--title'])).toBe('123456');
+  });
+
+  test('skips flag and its value, not confusing them with positional', () => {
+    // cn update --title 123 123  =>  subArgs: ['--title', '123', '123']  =>  positional is second 123
+    expect(findPositional(['--title', '123', '123'], ['--title'])).toBe('123');
+  });
+
+  test('id equals title value — skips by index not value', () => {
+    // cn update 123 --title 123  =>  subArgs: ['123', '--title', '123']  =>  positional is first 123
+    expect(findPositional(['123', '--title', '123'], ['--title'])).toBe('123');
+  });
+
+  test('returns undefined when no positional', () => {
+    expect(findPositional(['--title', 'Some Title'], ['--title'])).toBeUndefined();
+  });
+
+  test('create: title equals space value', () => {
+    // cn create ENG --space ENG  =>  subArgs: ['ENG', '--space', 'ENG']  =>  positional is ENG
+    expect(findPositional(['ENG', '--space', 'ENG'], ['--space', '--parent', '--format'])).toBe('ENG');
+  });
+});

package/src/cli/commands/duplicate-check.ts

@@ -1,89 +0,0 @@
-import { confirm } from '@inquirer/prompts';
-import chalk from 'chalk';
-import {
-  checkFileForDuplicates,
-  findBestDuplicate,
-  findDuplicatePageIds,
-  scanFilesForHealthCheck,
-  type DuplicatePageId,
-} from '../../lib/health-check.js';
-
-/**
- * Display duplicate page_id information
- */
-export function displayDuplicates(duplicates: DuplicatePageId[]): void {
-  console.log(chalk.red('Duplicate page_ids detected:'));
-  for (const dup of duplicates) {
-    const best = findBestDuplicate(dup.files);
-    console.log(chalk.yellow(`\n  page_id: ${dup.pageId}`));
-    for (const file of dup.files) {
-      const isBest = file.path === best.path;
-      const marker = isBest ? chalk.green(' (keep)') : chalk.red(' (stale)');
-      const version = file.version ? `v${file.version}` : 'v?';
-      console.log(`    ${isBest ? chalk.green('*') : chalk.red('x')} ${file.path}${marker} - ${version}`);
-    }
-  }
-  console.log('');
-}
-
-/**
- * Check for duplicate page_ids before push and prompt for confirmation
- * Returns true if push should continue, false if user cancelled
- */
-export async function checkDuplicatesBeforePush(directory: string): Promise<boolean> {
-  const allFiles = scanFilesForHealthCheck(directory);
-  const duplicates = findDuplicatePageIds(allFiles);
-
-  if (duplicates.length === 0) {
-    return true;
-  }
-
-  displayDuplicates(duplicates);
-
-  const shouldContinue = await confirm({
-    message: 'Continue with push? (Stale files may cause version conflicts)',
-    default: false,
-  });
-
-  if (!shouldContinue) {
-    console.log(chalk.gray('Run "cn doctor" to fix duplicate page_ids.'));
-    return false;
-  }
-  console.log('');
-  return true;
-}
-
-/**
- * Display version conflict guidance, checking for duplicates that may explain the conflict
- * This is called when a version mismatch is detected during push
- */
-export function displayVersionConflictGuidance(directory: string, relativePath: string, remoteVersion: number): void {
-  const { hasDuplicates, duplicates } = checkFileForDuplicates(directory, relativePath);
-
-  if (hasDuplicates) {
-    const newerDuplicate = duplicates.find((d) => (d.version || 0) >= remoteVersion);
-    if (newerDuplicate) {
-      console.log(chalk.yellow('Found another file with the same page_id:'));
-      console.log(chalk.yellow(`  ${newerDuplicate.path} (v${newerDuplicate.version || '?'})`));
-      console.log('');
-      console.log(chalk.gray('This usually happens when a page was moved on Confluence.'));
-      console.log(chalk.gray(`The file at ${relativePath} appears to be stale.`));
-      console.log('');
-      console.log(chalk.gray('Recommended actions:'));
-      console.log(chalk.gray(`  1. Delete the stale file: rm "${relativePath}"`));
-      console.log(chalk.gray(`  2. Or run "cn doctor" to fix all duplicates`));
-    } else {
-      console.log(chalk.yellow('Found duplicate files with the same page_id:'));
-      for (const dup of duplicates) {
-        console.log(chalk.yellow(`  ${dup.path} (v${dup.version || '?'})`));
-      }
-      console.log('');
-      console.log(chalk.gray('Run "cn doctor" to identify and fix duplicates.'));
-    }
-  } else {
-    console.log(chalk.yellow('The page has been modified on Confluence since your last pull.'));
-    console.log(chalk.gray('Options:'));
-    console.log(chalk.gray(`  - Run "cn pull --page ${relativePath}" to get the latest version`));
-    console.log(chalk.gray(`  - Run "cn push ${relativePath} --force" to overwrite remote changes`));
-  }
-}

package/src/cli/commands/file-rename.ts

@@ -1,113 +0,0 @@
-/**
- * File rename utilities for push operations
- */
-
-import { existsSync, mkdtempSync, renameSync, rmSync, unlinkSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { basename, dirname, join } from 'node:path';
-import chalk from 'chalk';
-import { slugify, updateReferencesAfterRename } from '../../lib/markdown/index.js';
-
-// Index files that should not be renamed based on title (case-insensitive check)
-const INDEX_FILES = new Set(['index.md', 'readme.md']);
-
-/**
- * Result of file rename operation
- */
-export interface RenameResult {
-  finalPath: string;
-  wasRenamed: boolean;
-}
-
-/**
- * Handle file renaming when title changes
- * Returns the final local path for updating sync state
- * Uses atomic operations: writes to temp file first, then renames
- * Also updates references in other markdown files when a rename occurs
- */
-export function handleFileRename(
-  filePath: string,
-  originalRelativePath: string,
-  expectedTitle: string,
-  updatedMarkdown: string,
-  spaceRoot?: string,
-): RenameResult {
-  const currentFilename = basename(filePath);
-  const currentDir = dirname(filePath);
-  const expectedSlug = slugify(expectedTitle);
-  const expectedFilename = `${expectedSlug}.md`;
-  // Track the current relative path (will be updated if file is renamed)
-  const currentRelativePath = originalRelativePath.replace(/^\.\//, '');
-  let finalLocalPath = currentRelativePath;
-
-  const isIndexFile = INDEX_FILES.has(currentFilename.toLowerCase());
-
-  // Write to temp file first for atomicity
-  const tempDir = mkdtempSync(join(tmpdir(), 'cn-push-'));
-  const tempFile = join(tempDir, 'temp.md');
-  writeFileSync(tempFile, updatedMarkdown, 'utf-8');
-
-  try {
-    if (!isIndexFile && expectedFilename !== currentFilename && expectedSlug) {
-      const newFilePath = join(currentDir, expectedFilename);
-
-      if (existsSync(newFilePath)) {
-        console.log(chalk.yellow(`  Note: Keeping filename "${currentFilename}" (${expectedFilename} already exists)`));
-        // Atomic rename: temp file -> original file
-        renameSync(tempFile, filePath);
-        return { finalPath: finalLocalPath, wasRenamed: false };
-      }
-
-      // Warn user about automatic rename
-      console.log(chalk.cyan(`  Note: File will be renamed to match page title`));
-
-      // Atomic operations: remove old file, move temp to new location
-      const backupPath = `${filePath}.bak`;
-      renameSync(filePath, backupPath);
-      try {
-        renameSync(tempFile, newFilePath);
-        // Clean up backup only after successful rename
-        try {
-          unlinkSync(backupPath);
-        } catch {
-          // Ignore cleanup errors
-        }
-      } catch (error) {
-        // Restore from backup if rename fails
-        try {
-          renameSync(backupPath, filePath);
-        } catch {
-          // If restore fails, log the backup location
-          console.error(chalk.red(`  Error: Failed to rename file. Backup available at: ${backupPath}`));
-        }
-        throw error;
-      }
-
-      const relativeDir = dirname(currentRelativePath);
-      const newRelativePath = relativeDir === '.' ? expectedFilename : join(relativeDir, expectedFilename);
-      finalLocalPath = newRelativePath;
-      console.log(chalk.cyan(`  Renamed: ${currentFilename} → ${expectedFilename}`));
-
-      // Update references in other markdown files that link to the old filename
-      if (spaceRoot) {
-        const updatedFiles = updateReferencesAfterRename(spaceRoot, currentRelativePath, newRelativePath);
-        if (updatedFiles.length > 0) {
-          console.log(chalk.cyan(`  Updated ${updatedFiles.length} file(s) with new link path`));
-        }
-      }
-
-      return { finalPath: finalLocalPath, wasRenamed: true };
-    }
-
-    // Atomic rename: temp file -> original file
-    renameSync(tempFile, filePath);
-    return { finalPath: finalLocalPath, wasRenamed: false };
-  } finally {
-    // Always clean up temp directory
-    try {
-      rmSync(tempDir, { recursive: true, force: true });
-    } catch {
-      // Ignore cleanup errors
-    }
-  }
-}