confluence-exporter 1.0.0

package/src/commands/plan.command.ts

@@ -0,0 +1,318 @@
+/**
+ * Plan command handler - Creates _queue.yaml for download
+ */
+
+import * as fs from 'fs';
+import path from 'path';
+import yaml from 'yaml';
+import type { ConfluenceConfig, PageIndexEntry, PageTreeNode } from '../types.js';
+import type { CommandContext, CommandHandler } from './types.js';
+import { findExistingFile, checkPageStatus, updateIndexEntry } from '../utils.js';
+
+export class PlanCommand implements CommandHandler {
+  queuePath: string;
+  treePath: string;
+  tree: PageTreeNode[];
+
+  constructor(private config: ConfluenceConfig) {
+    this.queuePath = path.join(this.config.outputDir, '_queue.yaml');
+    this.treePath = path.join(this.config.outputDir, '_tree.yaml');
+    this.tree = [];
+  }
+
+  async execute(context: CommandContext): Promise<void> {
+
+    // Create output directory if it doesn't exist
+    fs.mkdirSync(this.config.outputDir, { recursive: true });
+
+    // Check for --force flag
+    const forceMode = this.config.force === true;
+    if (forceMode) {
+      console.log('\n⚠️  Force mode enabled - all pages will be queued regardless of status\n');
+    }
+
+    // Step 1: Build complete tree structure (no limits applied here)
+    this.tree = this.buildTreeFromIndex();
+
+    if (this.config.pageId) {
+      // Build tree from specific page and all children
+      console.log(`Building tree from specific page: ${this.config.pageId}`);
+      this.tree = [this.collectPageTree(this.config.pageId)];
+    }
+
+    // Step 2: Create queue from tree with smart filtering
+    console.log(`\nCreating download queue from tree...`);
+    try {
+      const allPages = this.flattenTreeArray(this.tree);
+      console.log(`Flattened tree to ${allPages.length} pages`);
+      
+      // Apply smart filtering (check if pages need downloading)
+      const { pagesToQueue, stats } = this.filterPagesForQueue(allPages, forceMode);
+      
+      // Apply limit if specified (only affects queue, not tree)
+      const finalQueue = this.config.limit ? pagesToQueue.slice(0, this.config.limit) : pagesToQueue;
+
+      if (this.config.limit && pagesToQueue.length > this.config.limit) {
+        console.log(`Limiting queue to first ${this.config.limit} pages`);
+      }
+
+      this.writeQueue(this.queuePath, this.config, finalQueue);
+
+      console.log(`\n✓ Queue created: ${this.queuePath}`);
+      console.log(`  📊 Statistics:`);
+      console.log(`     New pages:     ${stats.new}`);
+      console.log(`     Updated pages: ${stats.updated}`);
+      console.log(`     Skipped:       ${stats.skipped} (up-to-date)`);
+      console.log(`     Total queued:  ${finalQueue.length}`);
+      console.log(`     Total in tree: ${allPages.length}`);
+    } catch (error) {
+      throw new Error(`Failed to create queue from tree: ${error instanceof Error ? error.message : error}`);
+    }
+  }
+
+  /**
+   * Recursively collect a page and all its descendants
+   */
+  private collectPageTree(pageId: string, depth: number = 0): PageTreeNode {
+    const indent = '  '.repeat(depth);
+    
+    // Find the page in the tree
+    const node = this.findNodeInTree(this.tree, pageId);
+    if (!node) {
+      throw new Error(`Page ${pageId} not found in tree`);
+    }
+    
+    console.log(`${indent}Found page: ${node.title} (${node.id})`);
+    return node;
+  }
+
+  /**
+   * Find a node by ID in the tree structure
+   */
+  private findNodeInTree(nodes: PageTreeNode[], pageId: string): PageTreeNode | null {
+    for (const node of nodes) {
+      if (node.id === pageId) {
+        return node;
+      }
+      if (node.children && node.children.length > 0) {
+        const found = this.findNodeInTree(node.children, pageId);
+        if (found) {
+          return found;
+        }
+      }
+    }
+    return null;
+  }
+
+  /**
+   * Flatten tree structure to array of PageIndexEntry
+   */
+  private flattenTree(node: PageTreeNode, result: PageIndexEntry[] = []): PageIndexEntry[] {
+    result.push({
+      id: node.id,
+      title: node.title,
+      version: node.version,
+      parentId: node.parentId,
+      modifiedDate: node.modifiedDate,
+      indexedDate: new Date().toISOString(),
+      pageNumber: 0
+    });
+    
+    if (node.children) {
+      for (const child of node.children) {
+        this.flattenTree(child, result);
+      }
+    }
+    
+    return result;
+  }
+
+  /**
+   * Flatten array of tree nodes to array of PageIndexEntry
+   */
+  private flattenTreeArray(trees: PageTreeNode[]): PageIndexEntry[] {
+    const result: PageIndexEntry[] = [];
+    for (const tree of trees) {
+      this.flattenTree(tree, result);
+    }
+    return result;
+  }
+
+  /**
+   * Filter pages based on whether they need to be downloaded
+   * Checks for existing files and compares versions/dates
+   * 
+   * @param pages - All pages from the tree
+   * @param forceMode - If true, skip all checks and include all pages
+   * @returns Filtered pages with queueReason and statistics
+   */
+  private filterPagesForQueue(
+    pages: PageIndexEntry[],
+    forceMode: boolean
+  ): { pagesToQueue: PageIndexEntry[]; stats: { new: number; updated: number; skipped: number } } {
+    const pagesToQueue: PageIndexEntry[] = [];
+    const stats = { new: 0, updated: 0, skipped: 0 };
+
+    console.log('\n📋 Checking page status...');
+
+    // Force mode: include all pages without checking
+    if (forceMode) {
+      for (const page of pages) {
+        pagesToQueue.push({ ...page, queueReason: 'new' });
+        stats.new++;
+      }
+      return { pagesToQueue, stats };
+    }
+
+    // Read index once for all lookups
+    const indexPath = path.join(this.config.outputDir, '_index.yaml');
+    const indexEntries = this.loadIndexEntries(indexPath);
+    const indexMap = new Map(indexEntries.map(entry => [entry.id, entry]));
+
+    console.log(`Loaded ${indexEntries.length} entries from index for status checking`);
+
+    // Process pages in batches of 100 for better performance
+    const batchSize = 100;
+    for (let i = 0; i < pages.length; i += batchSize) {
+      const batch = pages.slice(i, i + batchSize);
+      console.log(`Processing batch ${Math.floor(i / batchSize) + 1}/${Math.ceil(pages.length / batchSize)} (${batch.length} pages)`);
+
+      for (const page of batch) {
+        // Check if page has been downloaded by looking at index entry
+        const existingEntry = indexMap.get(page.id);
+        
+        if (!existingEntry || !existingEntry.downloadedVersion) {
+          // Page not downloaded yet
+          console.log(`  [NEW] ${page.title} (${page.id})`);
+          pagesToQueue.push({ ...page, queueReason: 'new' });
+          stats.new++;
+          continue;
+        }
+
+        // Check if page needs update
+        const status = checkPageStatus(existingEntry);
+
+        if (status.needsDownload) {
+          const details = status.details ? ` - ${status.details}` : '';
+          console.log(`  [UPDATE] ${page.title} (${page.id})${details}`);
+          pagesToQueue.push({ ...page, queueReason: 'updated' });
+          stats.updated++;
+        } else {
+          console.log(`  [SKIP] ${page.title} (${page.id}) - up to date (v${existingEntry.downloadedVersion})`);
+          stats.skipped++;
+        }
+      }
+    }
+
+    return { pagesToQueue, stats };
+  }
+
+  /**
+   * Load all index entries from _index.yaml file
+   */
+  private loadIndexEntries(indexPath: string): PageIndexEntry[] {
+    if (!fs.existsSync(indexPath)) return [];
+
+    try {
+      const content = fs.readFileSync(indexPath, 'utf-8');
+      return yaml.parse(content) as PageIndexEntry[];
+    } catch (error) {
+      console.warn(`Warning: Failed to load index file ${indexPath}: ${error}`);
+      return [];
+    }
+  }
+
+  /**
+   * Build tree structure from flat index
+   */
+  private buildTreeFromIndex(): PageTreeNode[] {
+    const indexPath = path.join(this.config.outputDir, '_index.yaml');
+
+    const yamlContent = fs.readFileSync(indexPath, 'utf-8');
+    const pages = yaml.parse(yamlContent) as PageIndexEntry[];
+
+    console.log(`Read ${pages.length} pages from _index.yaml`);
+
+    const nodeMap = new Map<string, PageTreeNode>();
+    const roots: PageTreeNode[] = [];
+    
+    // First pass: create all nodes
+    for (const page of pages) {
+      nodeMap.set(page.id, {
+        id: page.id,
+        title: page.title,
+        version: page.version,
+        parentId: page.parentId,
+        modifiedDate: page.modifiedDate,
+        children: []
+      });
+    }
+    
+    // Second pass: build tree structure
+    for (const page of pages) {
+      const node = nodeMap.get(page.id);
+      if (!node) continue;
+      
+      if (page.parentId && nodeMap.has(page.parentId)) {
+        // Add as child to parent
+        const parent = nodeMap.get(page.parentId);
+        if (parent?.children) {
+          parent.children.push(node);
+        }
+      } else {
+        // No parent or parent not in index - it's a root
+        roots.push(node);
+      }
+    }
+    this.writeTree(roots);
+    console.log(`✓ Complete tree structure saved: ${this.treePath}`);
+
+    return roots;
+  }
+
+  /**
+   * Write _tree.yaml file with hierarchical structure
+   */
+  private writeTree(tree: PageTreeNode[]): void {
+    const header = `# Confluence Page Tree
+# Space: ${this.config.spaceKey}
+# Created: ${new Date().toISOString()}
+
+`;
+
+    const yamlContent = yaml.stringify(tree, {
+      indent: 2,
+      lineWidth: 0 // No line wrapping
+    });
+
+    fs.writeFileSync(this.treePath, header + yamlContent, 'utf-8');
+  }
+
+  /**
+   * Write _queue.yaml file
+   */
+  private writeQueue(queuePath: string, config: CommandContext['config'], pages: PageIndexEntry[]): void {
+    const header = `# Confluence Download Queue
+# Space: ${config.spaceKey}
+# Created: ${new Date().toISOString()}
+# Total Pages: ${pages.length}
+
+`;
+
+    fs.writeFileSync(queuePath, header, 'utf-8');
+
+    // Write each page as YAML array entry
+    for (const page of pages) {
+      const yamlDoc = yaml.stringify(page).trim();
+      const lines = yamlDoc.split('\n');
+      const arrayItem = lines.map((line, index) => {
+        if (index === 0) {
+          return `- ${line}`;
+        }
+        return `  ${line}`;
+      }).join('\n');
+
+      fs.appendFileSync(queuePath, arrayItem + '\n', 'utf-8');
+    }
+  }
+}

package/src/commands/registry.ts

@@ -0,0 +1,39 @@
+/**
+ * Command registry - maps command names to handlers
+ */
+
+import { HelpCommand } from './help.command.js';
+import { IndexCommand } from './index.command.js';
+import { UpdateCommand } from './update.command.js';
+import { PlanCommand } from './plan.command.js';
+import { DownloadCommand } from './download.command.js';
+import { TransformCommand } from './transform.command.js';
+import type { Command, CommandContext, CommandHandler } from './types.js';
+import { ConfluenceConfig } from 'src/types.js';
+
+export class CommandRegistry {
+  private handlers: Map<Command, CommandHandler>;
+
+  constructor(config?: ConfluenceConfig) {
+    this.handlers = new Map<Command, CommandHandler>([
+      ['help', new HelpCommand()],
+      ['index', new IndexCommand(config)],
+      ['update', new UpdateCommand(config)],
+      ['plan', new PlanCommand(config)],
+      ['download', new DownloadCommand(config)],
+      ['transform', new TransformCommand(config)]
+    ]);
+  }
+
+  getHandler(command: Command): CommandHandler | undefined {
+    return this.handlers.get(command);
+  }
+
+  isValidCommand(command: string): command is Command {
+    return this.handlers.has(command as Command);
+  }
+
+  getValidCommands(): Command[] {
+    return Array.from(this.handlers.keys());
+  }
+}