@aaronshaf/confluence-cli 0.1.15

package/src/lib/formatters.ts

@@ -0,0 +1,314 @@
+import chalk from 'chalk';
+import type { Page, Space } from './confluence-client/types.js';
+import type { SyncDiff } from './sync/sync-engine.js';
+
+/**
+ * Base formatter interface
+ */
+export interface Formatter {
+  formatSpaces(spaces: Space[]): string;
+  formatPages(pages: Page[], spaceKey: string): string;
+  formatSyncDiff(diff: SyncDiff): string;
+  formatStatus(status: StatusInfo): string;
+  formatTree(nodes: TreeNode[], depth?: number): string;
+}
+
+export interface StatusInfo {
+  connected: boolean;
+  configured: boolean;
+  initialized: boolean;
+  confluenceUrl?: string;
+  email?: string;
+  spaceKey?: string;
+  spaceName?: string;
+  lastSync?: string;
+  pageCount?: number;
+  pendingChanges?: {
+    added: number;
+    modified: number;
+    deleted: number;
+  };
+}
+
+export interface TreeNode {
+  id: string;
+  title: string;
+  children: TreeNode[];
+  depth?: number;
+}
+
+/**
+ * XML escape helper
+ */
+export function escapeXml(text: string): string {
+  return text
+    .replace(/&/g, '&')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;')
+    .replace(/'/g, '&apos;');
+}
+
+/**
+ * Human-readable formatter with colors
+ */
+export class HumanFormatter implements Formatter {
+  formatSpaces(spaces: Space[]): string {
+    if (spaces.length === 0) {
+      return chalk.yellow('No spaces found.');
+    }
+
+    const lines = [chalk.bold('Spaces:'), ''];
+    for (const space of spaces) {
+      lines.push(`  ${chalk.cyan(space.key)} - ${space.name}`);
+      if (space.description?.plain?.value) {
+        lines.push(chalk.gray(`    ${space.description.plain.value.substring(0, 80)}...`));
+      }
+    }
+    return lines.join('\n');
+  }
+
+  formatPages(pages: Page[], spaceKey: string): string {
+    if (pages.length === 0) {
+      return chalk.yellow(`No pages found in space ${spaceKey}.`);
+    }
+
+    const lines = [chalk.bold(`Pages in ${spaceKey}:`), ''];
+    for (const page of pages) {
+      lines.push(`  ${chalk.cyan(page.id)} - ${page.title}`);
+    }
+    lines.push('', chalk.gray(`Total: ${pages.length} pages`));
+    return lines.join('\n');
+  }
+
+  formatSyncDiff(diff: SyncDiff): string {
+    const lines: string[] = [];
+
+    if (diff.added.length > 0) {
+      lines.push(chalk.green.bold('Added:'));
+      for (const change of diff.added) {
+        lines.push(chalk.green(`  + ${change.title}`));
+      }
+      lines.push('');
+    }
+
+    if (diff.modified.length > 0) {
+      lines.push(chalk.yellow.bold('Modified:'));
+      for (const change of diff.modified) {
+        lines.push(chalk.yellow(`  ~ ${change.title}`));
+      }
+      lines.push('');
+    }
+
+    if (diff.deleted.length > 0) {
+      lines.push(chalk.red.bold('Deleted:'));
+      for (const change of diff.deleted) {
+        lines.push(chalk.red(`  - ${change.title}`));
+      }
+      lines.push('');
+    }
+
+    if (diff.added.length === 0 && diff.modified.length === 0 && diff.deleted.length === 0) {
+      lines.push(chalk.gray('No changes detected.'));
+    } else {
+      lines.push(
+        chalk.gray(
+          `Summary: ${diff.added.length} added, ${diff.modified.length} modified, ${diff.deleted.length} deleted`,
+        ),
+      );
+    }
+
+    return lines.join('\n');
+  }
+
+  formatStatus(status: StatusInfo): string {
+    const lines: string[] = [];
+
+    if (!status.configured) {
+      lines.push(chalk.red('Not configured.'));
+      lines.push(chalk.gray('Run "cn setup" to configure Confluence credentials.'));
+      return lines.join('\n');
+    }
+
+    lines.push(chalk.bold('Configuration:'));
+    lines.push(`  URL: ${chalk.cyan(status.confluenceUrl || 'N/A')}`);
+    lines.push(`  Email: ${chalk.cyan(status.email || 'N/A')}`);
+    lines.push('');
+
+    if (status.connected) {
+      lines.push(chalk.green('✓ Connected to Confluence'));
+    } else {
+      lines.push(chalk.red('✗ Not connected'));
+    }
+    lines.push('');
+
+    if (!status.initialized) {
+      lines.push(chalk.yellow('No space initialized in current directory.'));
+      lines.push(chalk.gray('Run "cn sync --init <SPACE_KEY>" to initialize.'));
+    } else {
+      lines.push(chalk.bold('Space:'));
+      lines.push(`  Key: ${chalk.cyan(status.spaceKey || 'N/A')}`);
+      lines.push(`  Name: ${status.spaceName || 'N/A'}`);
+      lines.push(`  Last Sync: ${status.lastSync || 'Never'}`);
+      lines.push(`  Pages: ${status.pageCount || 0}`);
+
+      if (status.pendingChanges) {
+        const { added, modified, deleted } = status.pendingChanges;
+        if (added > 0 || modified > 0 || deleted > 0) {
+          lines.push('');
+          lines.push(chalk.bold('Pending Changes:'));
+          if (added > 0) lines.push(chalk.green(`  + ${added} new`));
+          if (modified > 0) lines.push(chalk.yellow(`  ~ ${modified} modified`));
+          if (deleted > 0) lines.push(chalk.red(`  - ${deleted} deleted`));
+        }
+      }
+    }
+
+    return lines.join('\n');
+  }
+
+  formatTree(nodes: TreeNode[], depth = 0): string {
+    const lines: string[] = [];
+
+    for (let i = 0; i < nodes.length; i++) {
+      const node = nodes[i];
+      const isLast = i === nodes.length - 1;
+      const prefix = depth === 0 ? '' : '  '.repeat(depth - 1) + (isLast ? '└── ' : '├── ');
+
+      lines.push(`${prefix}${node.title}`);
+
+      if (node.children.length > 0) {
+        lines.push(this.formatTree(node.children, depth + 1));
+      }
+    }
+
+    return lines.join('\n');
+  }
+}
+
+/**
+ * XML formatter for LLM consumption per ADR-0011
+ */
+export class XmlFormatter implements Formatter {
+  formatSpaces(spaces: Space[]): string {
+    const lines = ['<spaces>'];
+    for (const space of spaces) {
+      lines.push(`  <space key="${escapeXml(space.key)}" id="${escapeXml(space.id)}">`);
+      lines.push(`    <name>${escapeXml(space.name)}</name>`);
+      if (space.description?.plain?.value) {
+        lines.push(`    <description>${escapeXml(space.description.plain.value)}</description>`);
+      }
+      lines.push('  </space>');
+    }
+    lines.push('</spaces>');
+    return lines.join('\n');
+  }
+
+  formatPages(pages: Page[], spaceKey: string): string {
+    const lines = [`<pages space="${escapeXml(spaceKey)}" count="${pages.length}">`];
+    for (const page of pages) {
+      lines.push(`  <page id="${escapeXml(page.id)}">`);
+      lines.push(`    <title>${escapeXml(page.title)}</title>`);
+      if (page.parentId) {
+        lines.push(`    <parent-id>${escapeXml(page.parentId)}</parent-id>`);
+      }
+      lines.push('  </page>');
+    }
+    lines.push('</pages>');
+    return lines.join('\n');
+  }
+
+  formatSyncDiff(diff: SyncDiff): string {
+    const lines = [
+      `<sync-diff added="${diff.added.length}" modified="${diff.modified.length}" deleted="${diff.deleted.length}">`,
+    ];
+
+    if (diff.added.length > 0) {
+      lines.push('  <added>');
+      for (const change of diff.added) {
+        lines.push(`    <page id="${escapeXml(change.pageId)}" title="${escapeXml(change.title)}" />`);
+      }
+      lines.push('  </added>');
+    }
+
+    if (diff.modified.length > 0) {
+      lines.push('  <modified>');
+      for (const change of diff.modified) {
+        lines.push(`    <page id="${escapeXml(change.pageId)}" title="${escapeXml(change.title)}" />`);
+      }
+      lines.push('  </modified>');
+    }
+
+    if (diff.deleted.length > 0) {
+      lines.push('  <deleted>');
+      for (const change of diff.deleted) {
+        lines.push(`    <page id="${escapeXml(change.pageId)}" title="${escapeXml(change.title)}" />`);
+      }
+      lines.push('  </deleted>');
+    }
+
+    lines.push('</sync-diff>');
+    return lines.join('\n');
+  }
+
+  formatStatus(status: StatusInfo): string {
+    const lines = [
+      `<status configured="${status.configured}" connected="${status.connected}" initialized="${status.initialized}">`,
+    ];
+
+    if (status.configured) {
+      lines.push('  <configuration>');
+      if (status.confluenceUrl) lines.push(`    <url>${escapeXml(status.confluenceUrl)}</url>`);
+      if (status.email) lines.push(`    <email>${escapeXml(status.email)}</email>`);
+      lines.push('  </configuration>');
+    }
+
+    if (status.initialized) {
+      lines.push('  <space>');
+      if (status.spaceKey) lines.push(`    <key>${escapeXml(status.spaceKey)}</key>`);
+      if (status.spaceName) lines.push(`    <name>${escapeXml(status.spaceName)}</name>`);
+      if (status.lastSync) lines.push(`    <last-sync>${escapeXml(status.lastSync)}</last-sync>`);
+      if (status.pageCount !== undefined) lines.push(`    <page-count>${status.pageCount}</page-count>`);
+      lines.push('  </space>');
+
+      if (status.pendingChanges) {
+        const { added, modified, deleted } = status.pendingChanges;
+        lines.push(`  <pending-changes added="${added}" modified="${modified}" deleted="${deleted}" />`);
+      }
+    }
+
+    lines.push('</status>');
+    return lines.join('\n');
+  }
+
+  formatTree(nodes: TreeNode[], depth = 0): string {
+    if (depth === 0) {
+      const lines = ['<tree>'];
+      lines.push(this.formatTreeNodes(nodes));
+      lines.push('</tree>');
+      return lines.join('\n');
+    }
+    return this.formatTreeNodes(nodes);
+  }
+
+  private formatTreeNodes(nodes: TreeNode[]): string {
+    const lines: string[] = [];
+    for (const node of nodes) {
+      if (node.children.length > 0) {
+        lines.push(`  <page id="${escapeXml(node.id)}" title="${escapeXml(node.title)}">`);
+        lines.push(this.formatTreeNodes(node.children));
+        lines.push('  </page>');
+      } else {
+        lines.push(`  <page id="${escapeXml(node.id)}" title="${escapeXml(node.title)}" />`);
+      }
+    }
+    return lines.join('\n');
+  }
+}
+
+/**
+ * Get the appropriate formatter based on output mode
+ */
+export function getFormatter(xml: boolean): Formatter {
+  return xml ? new XmlFormatter() : new HumanFormatter();
+}

package/src/lib/health-check.ts

@@ -0,0 +1,204 @@
+/**
+ * Health check utilities for detecting issues in synced spaces
+ * Detects duplicate page_ids, orphaned files, stale files, etc.
+ */
+
+import { readFileSync, readdirSync, statSync, type Stats } from 'node:fs';
+import { join, relative } from 'node:path';
+import { EXCLUDED_DIRS, RESERVED_FILENAMES } from './file-scanner.js';
+import { parseMarkdown, type PageFrontmatter } from './markdown/index.js';
+
+/**
+ * Information about a scanned markdown file
+ */
+export interface ScannedFile {
+  path: string;
+  pageId?: string;
+  parentId?: string | null;
+  version?: number;
+  title?: string;
+  syncedAt?: string;
+  mtime: Date;
+}
+
+/**
+ * Information about a duplicate page_id
+ */
+export interface DuplicatePageId {
+  pageId: string;
+  files: ScannedFile[];
+}
+
+/**
+ * Result of a health check scan
+ */
+export interface HealthCheckResult {
+  /** All scanned files with their metadata */
+  files: ScannedFile[];
+  /** Files with duplicate page_ids */
+  duplicates: DuplicatePageId[];
+  /** Files without page_id (new/untracked) */
+  newFiles: ScannedFile[];
+  /** Files with page_id (tracked) */
+  trackedFiles: ScannedFile[];
+}
+
+/**
+ * Scan a directory and collect file metadata for health checks
+ */
+export function scanFilesForHealthCheck(directory: string): ScannedFile[] {
+  const files: ScannedFile[] = [];
+
+  function scan(dir: string): void {
+    let entries: string[];
+    try {
+      entries = readdirSync(dir);
+    } catch {
+      return;
+    }
+
+    for (const entry of entries) {
+      if (entry.startsWith('.')) continue;
+      if (EXCLUDED_DIRS.has(entry)) continue;
+
+      const fullPath = join(dir, entry);
+      let stat: Stats;
+      try {
+        stat = statSync(fullPath);
+      } catch {
+        continue;
+      }
+
+      if (stat.isDirectory()) {
+        scan(fullPath);
+      } else if (stat.isFile() && entry.endsWith('.md')) {
+        if (RESERVED_FILENAMES.has(entry.toLowerCase())) continue;
+
+        const relativePath = relative(directory, fullPath);
+        let content: string;
+        try {
+          content = readFileSync(fullPath, 'utf-8');
+        } catch {
+          continue;
+        }
+
+        const { frontmatter } = parseMarkdown(content);
+
+        files.push({
+          path: relativePath,
+          pageId: frontmatter.page_id,
+          parentId: frontmatter.parent_id,
+          version: frontmatter.version,
+          title: frontmatter.title,
+          syncedAt: frontmatter.synced_at,
+          mtime: stat.mtime,
+        });
+      }
+    }
+  }
+
+  scan(directory);
+  return files;
+}
+
+/**
+ * Find duplicate page_ids in scanned files
+ */
+export function findDuplicatePageIds(files: ScannedFile[]): DuplicatePageId[] {
+  const pageIdToFiles = new Map<string, ScannedFile[]>();
+
+  for (const file of files) {
+    if (!file.pageId) continue;
+
+    const existing = pageIdToFiles.get(file.pageId) || [];
+    existing.push(file);
+    pageIdToFiles.set(file.pageId, existing);
+  }
+
+  const duplicates: DuplicatePageId[] = [];
+  for (const [pageId, fileList] of pageIdToFiles) {
+    if (fileList.length > 1) {
+      // Sort by syncedAt (newest first) to help identify the "correct" one
+      fileList.sort((a, b) => {
+        if (!a.syncedAt && !b.syncedAt) return 0;
+        if (!a.syncedAt) return 1;
+        if (!b.syncedAt) return -1;
+        return new Date(b.syncedAt).getTime() - new Date(a.syncedAt).getTime();
+      });
+
+      duplicates.push({ pageId, files: fileList });
+    }
+  }
+
+  return duplicates;
+}
+
+/**
+ * Run a full health check on a directory
+ */
+export function runHealthCheck(directory: string): HealthCheckResult {
+  const files = scanFilesForHealthCheck(directory);
+  const duplicates = findDuplicatePageIds(files);
+  const newFiles = files.filter((f) => !f.pageId);
+  const trackedFiles = files.filter((f) => f.pageId);
+
+  return {
+    files,
+    duplicates,
+    newFiles,
+    trackedFiles,
+  };
+}
+
+/**
+ * Find the "best" file for a duplicate (newest synced_at, highest version)
+ * Returns the file that should be kept
+ * @throws Error if files array is empty
+ */
+export function findBestDuplicate(files: ScannedFile[]): ScannedFile {
+  if (files.length === 0) {
+    throw new Error('findBestDuplicate called with empty array');
+  }
+  return files.reduce((best, current) => {
+    // Prefer higher version
+    if ((current.version || 0) > (best.version || 0)) return current;
+    if ((current.version || 0) < (best.version || 0)) return best;
+
+    // Same version, prefer newer syncedAt
+    if (!best.syncedAt) return current;
+    if (!current.syncedAt) return best;
+
+    return new Date(current.syncedAt) > new Date(best.syncedAt) ? current : best;
+  });
+}
+
+/**
+ * Find stale duplicates (files that should be deleted)
+ */
+export function findStaleDuplicates(duplicate: DuplicatePageId): ScannedFile[] {
+  const best = findBestDuplicate(duplicate.files);
+  return duplicate.files.filter((f) => f.path !== best.path);
+}
+
+/**
+ * Check if a specific file has duplicates
+ */
+export function checkFileForDuplicates(
+  directory: string,
+  filePath: string,
+): { hasDuplicates: boolean; duplicates: ScannedFile[]; currentFile: ScannedFile | null } {
+  const files = scanFilesForHealthCheck(directory);
+  const currentFile = files.find((f) => f.path === filePath) || null;
+
+  if (!currentFile?.pageId) {
+    return { hasDuplicates: false, duplicates: [], currentFile };
+  }
+
+  const duplicates = files.filter((f) => f.pageId === currentFile.pageId && f.path !== filePath);
+
+  return {
+    hasDuplicates: duplicates.length > 0,
+    duplicates,
+    currentFile,
+  };
+}