@aaronshaf/confluence-cli 0.1.15

package/src/cli/commands/search.ts

@@ -0,0 +1,62 @@
+import chalk from 'chalk';
+import { ConfluenceClient } from '../../lib/confluence-client/index.js';
+import { ConfigManager } from '../../lib/config.js';
+import { EXIT_CODES } from '../../lib/errors.js';
+import { escapeXml } from '../../lib/formatters.js';
+
+export interface SearchCommandOptions {
+  space?: string;
+  limit?: number;
+  xml?: boolean;
+}
+
+export async function searchCommand(query: string, options: SearchCommandOptions = {}): Promise<void> {
+  const configManager = new ConfigManager();
+  const config = await configManager.getConfig();
+
+  if (!config) {
+    console.error(chalk.red('Not configured. Run: cn setup'));
+    process.exit(EXIT_CODES.CONFIG_ERROR);
+  }
+
+  let cql = `type=page AND text~"${query.replace(/"/g, '\\"')}"`;
+  if (options.space) {
+    cql += ` AND space="${options.space.replace(/"/g, '\\"')}"`;
+  }
+
+  const client = new ConfluenceClient(config);
+  const response = await client.search(cql, options.limit ?? 10);
+
+  if (options.xml) {
+    console.log('<results>');
+    for (const item of response.results) {
+      const content = item.content;
+      const webui = content?._links?.webui;
+      const id = content?.id ?? item.id ?? '';
+      const title = content?.title ?? item.title ?? '';
+      console.log(`  <result id="${escapeXml(id)}">`);
+      console.log(`    <title>${escapeXml(title)}</title>`);
+      if (item.excerpt) console.log(`    <excerpt>${escapeXml(item.excerpt)}</excerpt>`);
+      if (webui) console.log(`    <url>${escapeXml(`${config.confluenceUrl}/wiki${webui}`)}</url>`);
+      console.log('  </result>');
+    }
+    console.log('</results>');
+    return;
+  }
+
+  if (response.results.length === 0) {
+    console.log('No results found.');
+    return;
+  }
+
+  for (const item of response.results) {
+    const content = item.content;
+    const title = content?.title ?? item.title ?? '(untitled)';
+    const id = content?.id ?? item.id ?? '';
+    const webui = content?._links?.webui;
+    const url = webui ? `${config.confluenceUrl}/wiki${webui}` : '';
+    console.log(`${chalk.bold(title)}  ${chalk.gray(id)}`);
+    if (item.excerpt) console.log(`  ${chalk.gray(item.excerpt)}`);
+    if (url) console.log(`  ${chalk.blue(url)}`);
+  }
+}

package/src/cli/commands/setup.ts

@@ -0,0 +1,124 @@
+import { input, password } from '@inquirer/prompts';
+import chalk from 'chalk';
+import ora from 'ora';
+import { ConfluenceClient } from '../../lib/confluence-client/index.js';
+import { ConfigManager, type Config } from '../../lib/config.js';
+import { EXIT_CODES } from '../../lib/errors.js';
+
+/**
+ * Interactive setup command for configuring Confluence credentials
+ */
+export async function setup(): Promise<void> {
+  console.log(chalk.bold('\nConfluence CLI Setup\n'));
+  console.log(chalk.gray('This wizard will help you configure your Confluence credentials.'));
+  console.log(chalk.gray('You can create an API token at: https://id.atlassian.com/manage/api-tokens\n'));
+
+  const configManager = new ConfigManager();
+
+  // Check for existing config
+  const existingConfig = await configManager.getConfig();
+  if (existingConfig) {
+    console.log(chalk.yellow('Existing configuration found:'));
+    console.log(`  URL: ${existingConfig.confluenceUrl}`);
+    console.log(`  Email: ${existingConfig.email}`);
+    console.log('');
+  }
+
+  // Get Confluence URL
+  let confluenceUrl: string;
+  while (true) {
+    confluenceUrl = await input({
+      message: 'Confluence URL:',
+      default: existingConfig?.confluenceUrl,
+      validate: (value) => {
+        if (!value) return 'URL is required';
+        if (!ConfigManager.validateUrl(value)) {
+          return 'URL must be a Confluence Cloud URL (https://*.atlassian.net)';
+        }
+        return true;
+      },
+    });
+
+    // Normalize URL (remove trailing slashes)
+    confluenceUrl = confluenceUrl.replace(/\/+$/, '');
+    break;
+  }
+
+  // Get email
+  let email: string;
+  while (true) {
+    email = await input({
+      message: 'Email:',
+      default: existingConfig?.email,
+      validate: (value) => {
+        if (!value) return 'Email is required';
+        if (!ConfigManager.validateEmail(value)) {
+          return 'Invalid email format';
+        }
+        return true;
+      },
+    });
+    break;
+  }
+
+  // Get API token
+  const apiToken = await password({
+    message: 'API Token:',
+    mask: '*',
+    validate: (value) => {
+      if (!value) return 'API token is required';
+      return true;
+    },
+  });
+
+  // Create config object
+  const config: Config = {
+    confluenceUrl,
+    email,
+    apiToken,
+  };
+
+  // Verify connection
+  const spinner = ora('Verifying connection...').start();
+
+  try {
+    const client = new ConfluenceClient(config);
+    await client.verifyConnection();
+    spinner.succeed('Connected to Confluence successfully!');
+  } catch (error) {
+    spinner.fail('Connection failed');
+
+    if (error instanceof Error) {
+      if (error.message.includes('401') || error.message.includes('Invalid credentials')) {
+        console.error(chalk.red('\nAuthentication failed. Please check your email and API token.'));
+        console.log(chalk.gray('Make sure you are using an API token, not your account password.'));
+        console.log(chalk.gray('Create a token at: https://id.atlassian.com/manage/api-tokens'));
+      } else if (error.message.includes('403') || error.message.includes('Access denied')) {
+        console.error(chalk.red('\nPermission denied. Your account may not have access to Confluence.'));
+      } else if (error.message.includes('Network error') || error.message.includes('ENOTFOUND')) {
+        console.error(chalk.red('\nCould not connect to the Confluence URL.'));
+        console.log(chalk.gray('Please verify the URL is correct and accessible.'));
+      } else {
+        console.error(chalk.red(`\nError: ${error.message}`));
+      }
+    }
+
+    process.exit(EXIT_CODES.AUTH_ERROR);
+  }
+
+  // Save configuration
+  const saveSpinner = ora('Saving configuration...').start();
+
+  try {
+    await configManager.setConfig(config);
+    saveSpinner.succeed(`Configuration saved to ${configManager.getConfigPath()}`);
+  } catch (error) {
+    saveSpinner.fail('Failed to save configuration');
+    console.error(chalk.red(error instanceof Error ? error.message : 'Unknown error'));
+    process.exit(EXIT_CODES.CONFIG_ERROR);
+  }
+
+  console.log('');
+  console.log(chalk.green('Setup complete!'));
+  console.log(chalk.gray('You can now use "cn sync --init <SPACE_KEY>" to sync a Confluence space.'));
+}

package/src/cli/commands/spaces.ts

@@ -0,0 +1,42 @@
+import chalk from 'chalk';
+import { ConfluenceClient } from '../../lib/confluence-client/index.js';
+import { ConfigManager } from '../../lib/config.js';
+import { EXIT_CODES } from '../../lib/errors.js';
+import { escapeXml } from '../../lib/formatters.js';
+
+export interface SpacesCommandOptions {
+  xml?: boolean;
+}
+
+export async function spacesCommand(options: SpacesCommandOptions = {}): Promise<void> {
+  const configManager = new ConfigManager();
+  const config = await configManager.getConfig();
+
+  if (!config) {
+    console.error(chalk.red('Not configured. Run: cn setup'));
+    process.exit(EXIT_CODES.CONFIG_ERROR);
+  }
+
+  const client = new ConfluenceClient(config);
+  const spaces = await client.getAllSpaces();
+
+  if (options.xml) {
+    console.log('<spaces>');
+    for (const space of spaces) {
+      console.log(
+        `  <space id="${escapeXml(space.id)}" key="${escapeXml(space.key)}">${escapeXml(space.name)}</space>`,
+      );
+    }
+    console.log('</spaces>');
+    return;
+  }
+
+  if (spaces.length === 0) {
+    console.log('No spaces found.');
+    return;
+  }
+
+  for (const space of spaces) {
+    console.log(`${chalk.bold(space.key)}  ${space.name}  ${chalk.gray(space.id)}`);
+  }
+}

package/src/cli/commands/status.ts

@@ -0,0 +1,88 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import { ConfluenceClient } from '../../lib/confluence-client/index.js';
+import { ConfigManager } from '../../lib/config.js';
+import { EXIT_CODES } from '../../lib/errors.js';
+import { getFormatter, type StatusInfo } from '../../lib/formatters.js';
+import { buildPageStateFromFiles } from '../../lib/page-state.js';
+import { readSpaceConfig } from '../../lib/space-config.js';
+import { SyncEngine } from '../../lib/sync/index.js';
+
+export interface StatusCommandOptions {
+  xml?: boolean;
+}
+
+/**
+ * Status command - shows connection and sync status
+ */
+export async function statusCommand(options: StatusCommandOptions = {}): Promise<void> {
+  const configManager = new ConfigManager();
+  const config = await configManager.getConfig();
+  const formatter = getFormatter(options.xml || false);
+
+  const status: StatusInfo = {
+    configured: !!config,
+    connected: false,
+    initialized: false,
+  };
+
+  // If not configured, show message and exit
+  if (!config) {
+    console.log(formatter.formatStatus(status));
+    process.exit(EXIT_CODES.CONFIG_ERROR);
+  }
+
+  status.confluenceUrl = config.confluenceUrl;
+  status.email = config.email;
+
+  // Check connection
+  const spinner = options.xml ? null : ora('Checking connection...').start();
+
+  try {
+    const client = new ConfluenceClient(config);
+    await client.verifyConnection();
+    status.connected = true;
+    spinner?.succeed('Connected to Confluence');
+  } catch (_error) {
+    status.connected = false;
+    spinner?.fail('Not connected');
+  }
+
+  // Check space configuration
+  const directory = process.cwd();
+  const spaceConfig = readSpaceConfig(directory);
+
+  if (spaceConfig) {
+    status.initialized = true;
+    status.spaceKey = spaceConfig.spaceKey;
+    status.spaceName = spaceConfig.spaceName;
+    status.lastSync = spaceConfig.lastSync;
+    status.pageCount = Object.keys(spaceConfig.pages).length;
+
+    // Check for pending changes if connected
+    if (status.connected) {
+      try {
+        const syncEngine = new SyncEngine(config);
+        const remotePages = await syncEngine.fetchPageTree(spaceConfig.spaceId);
+        // Per ADR-0024: Build PageStateCache for version comparison from frontmatter
+        const pageState = buildPageStateFromFiles(directory, spaceConfig.pages);
+        const diff = syncEngine.computeDiff(remotePages, spaceConfig, pageState);
+
+        status.pendingChanges = {
+          added: diff.added.length,
+          modified: diff.modified.length,
+          deleted: diff.deleted.length,
+        };
+      } catch (_error) {
+        // Ignore errors when checking pending changes
+      }
+    }
+  }
+
+  // Clear spinner if it's still running
+  spinner?.stop();
+
+  // Output status
+  console.log('');
+  console.log(formatter.formatStatus(status));
+}

package/src/cli/commands/tree.ts

@@ -0,0 +1,190 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import { ConfluenceClient, type Page, type PageTreeNode } from '../../lib/confluence-client/index.js';
+import { ConfigManager } from '../../lib/config.js';
+import { EXIT_CODES } from '../../lib/errors.js';
+import { getFormatter, type TreeNode } from '../../lib/formatters.js';
+import { readSpaceConfig } from '../../lib/space-config.js';
+import { SyncEngine } from '../../lib/sync/index.js';
+
+export interface TreeCommandOptions {
+  spaceKey?: string;
+  remote?: boolean;
+  depth?: number;
+  xml?: boolean;
+}
+
+/**
+ * Convert PageTreeNode to TreeNode format for formatter
+ */
+function convertToTreeNode(node: PageTreeNode, maxDepth?: number, currentDepth = 0): TreeNode {
+  const shouldIncludeChildren = maxDepth === undefined || currentDepth < maxDepth;
+
+  return {
+    id: node.page.id,
+    title: node.page.title,
+    children: shouldIncludeChildren
+      ? node.children.map((child) => convertToTreeNode(child, maxDepth, currentDepth + 1))
+      : [],
+  };
+}
+
+/**
+ * Build tree from flat page list
+ */
+function buildTree(pages: Page[]): PageTreeNode[] {
+  const pageMap = new Map<string, PageTreeNode>();
+  const roots: PageTreeNode[] = [];
+
+  // Create nodes for all pages
+  for (const page of pages) {
+    pageMap.set(page.id, { page, children: [] });
+  }
+
+  // Build tree structure
+  for (const page of pages) {
+    const node = pageMap.get(page.id);
+    if (!node) continue;
+    if (page.parentId && pageMap.has(page.parentId)) {
+      pageMap.get(page.parentId)?.children.push(node);
+    } else {
+      roots.push(node);
+    }
+  }
+
+  // Sort children alphabetically
+  const sortChildren = (nodes: PageTreeNode[]): void => {
+    nodes.sort((a, b) => a.page.title.localeCompare(b.page.title));
+    for (const node of nodes) {
+      sortChildren(node.children);
+    }
+  };
+  sortChildren(roots);
+
+  return roots;
+}
+
+/**
+ * Tree command - displays page hierarchy
+ */
+export async function treeCommand(options: TreeCommandOptions = {}): Promise<void> {
+  const configManager = new ConfigManager();
+  const config = await configManager.getConfig();
+  const formatter = getFormatter(options.xml || false);
+
+  if (!config) {
+    console.error(chalk.red('Not configured. Please run "cn setup" first.'));
+    process.exit(EXIT_CODES.CONFIG_ERROR);
+  }
+
+  const directory = process.cwd();
+  let spaceId: string | undefined;
+  let spaceKey: string | undefined;
+
+  // Determine space to use
+  if (options.spaceKey) {
+    // Get space by key
+    const spinner = options.xml ? null : ora(`Fetching space ${options.spaceKey}...`).start();
+
+    try {
+      const client = new ConfluenceClient(config);
+      const space = await client.getSpaceByKey(options.spaceKey);
+      spaceId = space.id;
+      spaceKey = space.key;
+      spinner?.succeed(`Found space: ${space.name}`);
+    } catch (_error) {
+      spinner?.fail(`Space "${options.spaceKey}" not found`);
+      process.exit(EXIT_CODES.SPACE_NOT_FOUND);
+    }
+  } else {
+    // Use space from current directory
+    const spaceConfig = readSpaceConfig(directory);
+    if (!spaceConfig) {
+      console.error(chalk.red('No space configured in this directory.'));
+      console.log(chalk.gray('Specify a space key or run "cn sync --init <SPACE_KEY>" first.'));
+      process.exit(EXIT_CODES.CONFIG_ERROR);
+    }
+    spaceId = spaceConfig.spaceId;
+    spaceKey = spaceConfig.spaceKey;
+  }
+
+  // Fetch pages
+  const spinner = options.xml ? null : ora('Fetching page tree...').start();
+
+  try {
+    let pages: Page[];
+
+    if (options.remote !== false) {
+      // Fetch from API
+      if (!spaceId) {
+        spinner?.fail('Space ID not available');
+        process.exit(EXIT_CODES.CONFIG_ERROR);
+      }
+      const syncEngine = new SyncEngine(config);
+      pages = await syncEngine.fetchPageTree(spaceId);
+    } else {
+      // Use local cache
+      const spaceConfig = readSpaceConfig(directory);
+      if (!spaceConfig) {
+        spinner?.fail('No local sync state found. Use --remote to fetch from API.');
+        process.exit(EXIT_CODES.CONFIG_ERROR);
+      }
+
+      // Build pages from sync state, inferring hierarchy from file paths
+      // Per ADR-0024: pages is now Record<string, string> (pageId -> localPath)
+      // Create a map of directory paths to page IDs for parent lookup
+      // Note: sync-engine uses README.md for directory index files (per ADR-0005)
+      const pathToPageId = new Map<string, string>();
+      for (const [pageId, localPath] of Object.entries(spaceConfig.pages)) {
+        // For README.md files (directory index), map the parent directory
+        if (localPath.endsWith('/README.md') || localPath === 'README.md') {
+          const dir = localPath.replace('/README.md', '').replace('README.md', '');
+          pathToPageId.set(dir, pageId);
+        }
+      }
+
+      pages = Object.entries(spaceConfig.pages).map(([pageId, localPath]) => {
+        // Extract title from filename
+        const filename = localPath.split('/').pop() || '';
+        const title = filename.replace('.md', '').replace(/^README$/i, '') || pageId;
+
+        // Infer parent from path structure
+        const pathParts = localPath.split('/');
+        let parentId: string | null = null;
+
+        if (pathParts.length > 1) {
+          // For regular files, parent is the directory's README.md
+          // For README.md, parent is the grandparent directory's README.md
+          const isReadme = localPath.endsWith('/README.md');
+          const parentDir = isReadme ? pathParts.slice(0, -2).join('/') : pathParts.slice(0, -1).join('/');
+
+          if (parentDir) {
+            parentId = pathToPageId.get(parentDir) || null;
+          }
+        }
+
+        return {
+          id: pageId,
+          title: title || localPath,
+          spaceId: spaceConfig.spaceId,
+          parentId,
+        };
+      });
+    }
+
+    spinner?.succeed(`Found ${pages.length} pages`);
+
+    // Build tree
+    const tree = buildTree(pages);
+    const treeNodes = tree.map((node) => convertToTreeNode(node, options.depth));
+
+    // Output tree
+    console.log('');
+    console.log(options.xml ? '' : chalk.bold(`${spaceKey}:`));
+    console.log(formatter.formatTree(treeNodes));
+  } catch (error) {
+    spinner?.fail('Failed to fetch page tree');
+    console.error(chalk.red(error instanceof Error ? error.message : 'Unknown error'));
+    process.exit(EXIT_CODES.GENERAL_ERROR);
+  }
+}