k0ntext 3.3.0 → 3.5.0

package/src/template-sync/conflict-resolver.ts

@@ -0,0 +1,401 @@
+/**
+ * Conflict Resolver
+ *
+ * Handles interactive conflict resolution for template sync.
+ * Uses @inquirer/prompts for user interaction.
+ */
+
+import chalk from 'chalk';
+import { confirm, select, checkbox } from '@inquirer/prompts';
+import type { FileComparison, ResolutionChoice, ResolutionResult } from './types.js';
+import { TemplateMerger } from './merger.js';
+
+/**
+ * Resolution options for a single conflict
+ */
+export interface ResolutionOptions {
+  /** Whether to show diffs by default */
+  showDiff?: boolean;
+  /** Whether to allow batch resolution */
+  allowBatch?: boolean;
+  /** Default choice */
+  defaultChoice?: ResolutionChoice;
+}
+
+/**
+ * Batch resolution strategy
+ */
+export type BatchStrategy = 'keep-all' | 'overwrite-all' | 'individual';
+
+/**
+ * Handles interactive conflict resolution
+ */
+export class ConflictResolver {
+  constructor(
+    private projectRoot: string = process.cwd(),
+    private templateRoot: string
+  ) {}
+
+  /**
+   * Resolve conflicts interactively
+   *
+   * @param conflicts - Array of conflicting comparisons
+   * @param options - Resolution options
+   * @returns Array of resolution results
+   */
+  async resolveConflicts(
+    conflicts: FileComparison[],
+    options: ResolutionOptions = {}
+  ): Promise<ResolutionResult[]> {
+    if (conflicts.length === 0) {
+      return [];
+    }
+
+    const results: ResolutionResult[] = [];
+    const allowBatch = options.allowBatch !== false;
+
+    // Show summary
+    this.showConflictSummary(conflicts);
+
+    // Ask for batch vs individual resolution
+    if (allowBatch && conflicts.length > 1) {
+      const strategy = await this.promptBatchStrategy(conflicts.length);
+
+      if (strategy === 'keep-all') {
+        // Keep all local versions
+        for (const conflict of conflicts) {
+          results.push({ path: conflict.path, choice: 'keep-local' });
+        }
+        return results;
+      } else if (strategy === 'overwrite-all') {
+        // Overwrite all with templates
+        for (const conflict of conflicts) {
+          results.push({ path: conflict.path, choice: 'overwrite' });
+        }
+        return results;
+      }
+      // Otherwise, continue to individual resolution
+    }
+
+    // Individual resolution
+    for (const conflict of conflicts) {
+      const result = await this.resolveConflict(conflict, options);
+      results.push(result);
+
+      // Exit if user cancels
+      if (result.choice === 'skip') {
+        break;
+      }
+    }
+
+    return results;
+  }
+
+  /**
+   * Resolve a single conflict
+   *
+   * @param conflict - File comparison in conflict
+   * @param options - Resolution options
+   * @returns Resolution result
+   */
+  async resolveConflict(
+    conflict: FileComparison,
+    options: ResolutionOptions = {}
+  ): Promise<ResolutionResult> {
+    // Show file info
+    this.showConflictInfo(conflict);
+
+    // Ask for resolution
+    const choice = await this.promptResolution(conflict, options);
+
+    if (choice === 'show-diff') {
+      // Show diff and re-prompt
+      await this.showDiff(conflict);
+      return await this.resolveConflict(conflict, options);
+    }
+
+    return {
+      path: conflict.path,
+      choice
+    };
+  }
+
+  /**
+   * Prompt for batch resolution strategy
+   *
+   * @param count - Number of conflicts
+   * @returns Batch strategy
+   */
+  private async promptBatchStrategy(count: number): Promise<BatchStrategy> {
+    return await select({
+      message: `Resolve ${count} conflicts:`,
+      choices: [
+        {
+          name: 'Keep all local versions',
+          value: 'keep-all',
+          description: 'Skip updating all conflicted files'
+        },
+        {
+          name: 'Overwrite all with templates',
+          value: 'overwrite-all',
+          description: 'Replace all local files with template versions (backups created)'
+        },
+        {
+          name: 'Resolve individually',
+          value: 'individual',
+          description: 'Review and resolve each conflict separately'
+        }
+      ]
+    });
+  }
+
+  /**
+   * Prompt for resolution of a single conflict
+   *
+   * @param conflict - File comparison
+   * @param options - Resolution options
+   * @returns Resolution choice
+   */
+  private async promptResolution(
+    conflict: FileComparison,
+    options: ResolutionOptions
+  ): Promise<ResolutionChoice> {
+    const baseChoices = [
+      {
+        name: 'Show diff',
+        value: 'show-diff' as const,
+        description: 'View differences before deciding'
+      },
+      {
+        name: 'Keep local version',
+        value: 'keep-local' as const,
+        description: 'Skip updating this file (preserves your changes)'
+      },
+      {
+        name: 'Overwrite with template',
+        value: 'overwrite' as const,
+        description: 'Replace local file with template version (backup created)'
+      }
+    ];
+
+    const skipChoice = {
+      name: 'Skip for now',
+      value: 'skip' as const,
+      description: 'Leave unchanged and continue to next file'
+    };
+
+    const choices = options.defaultChoice !== 'skip'
+      ? [...baseChoices, skipChoice]
+      : baseChoices;
+
+    return await select<ResolutionChoice>({
+      message: 'How would you like to resolve this?',
+      choices,
+      default: options.defaultChoice ?? 'keep-local'
+    });
+  }
+
+  /**
+   * Show conflict information
+   *
+   * @param conflict - File comparison
+   */
+  private showConflictInfo(conflict: FileComparison): void {
+    console.log('');
+    console.log(chalk.cyan(`File: ${conflict.path}`));
+    console.log(chalk.dim(`State: ${this.formatState(conflict.state)}`));
+
+    if (conflict.userModified) {
+      console.log(chalk.yellow('  ⚠ You have modified this file'));
+    }
+
+    // Show file info if hashes differ
+    if (conflict.templateHash !== conflict.localHash) {
+      console.log(chalk.dim(`  Template hash: ${conflict.templateHash}`));
+      console.log(chalk.dim(`  Local hash: ${conflict.localHash}`));
+    }
+  }
+
+  /**
+   * Show conflict summary
+   *
+   * @param conflicts - Array of conflicts
+   */
+  private showConflictSummary(conflicts: FileComparison[]): void {
+    console.log('');
+    console.log(chalk.yellow(`⚠ ${conflicts.length} conflict(s) detected:\n`));
+
+    for (const conflict of conflicts) {
+      const icon = conflict.userModified ? '⚠' : '→';
+      const userFlag = conflict.userModified ? ' [modified]' : '';
+      console.log(chalk.dim(`  ${icon} ${conflict.path}${userFlag}`));
+    }
+
+    console.log('');
+  }
+
+  /**
+   * Show diff for a conflict
+   *
+   * @param conflict - File comparison
+   */
+  private async showDiff(conflict: FileComparison): Promise<void> {
+    const merger = new TemplateMerger(this.projectRoot, this.templateRoot, {
+      generateDiffs: true
+    });
+
+    const templatePath = path.join(this.templateRoot, conflict.path);
+    const localPath = path.join(this.projectRoot, '.claude', conflict.path);
+
+    const diff = await merger.generateDiff(localPath, templatePath);
+
+    console.log('');
+    console.log(chalk.gray('─'.repeat(60)));
+    console.log(chalk.bold('Diff:'));
+    console.log(chalk.gray('─'.repeat(60)));
+    console.log(chalk.dim(diff));
+    console.log(chalk.gray('─'.repeat(60)));
+    console.log('');
+
+    // Wait for user to acknowledge
+    await confirm({
+      message: 'Press Enter to continue...',
+      default: true
+    });
+  }
+
+  /**
+   * Format file state for display
+   *
+   * @param state - File state
+   * @returns Formatted state string
+   */
+  private formatState(state: FileComparison['state']): string {
+    const stateLabels: Record<FileComparison['state'], string> = {
+      identical: 'Identical to template',
+      'safe-update': 'Template updated (safe to apply)',
+      conflict: 'Modified in both template and locally',
+      new: 'New file in template',
+      deleted: 'Removed from template',
+      'user-only': 'User-only file (not in template)'
+    };
+
+    return stateLabels[state] || state;
+  }
+
+  /**
+   * Apply resolution results using merger
+   *
+   * @param resolutions - Array of resolution results
+   * @param conflicts - Original conflicts for reference
+   * @returns Results of applied resolutions
+   */
+  async applyResolutions(
+    resolutions: ResolutionResult[],
+    conflicts: FileComparison[]
+  ): Promise<{ applied: number; skipped: number; errors: number }> {
+    let applied = 0;
+    let skipped = 0;
+    let errors = 0;
+
+    const merger = new TemplateMerger(this.projectRoot, this.templateRoot);
+
+    for (const resolution of resolutions) {
+      const conflict = conflicts.find(c => c.path === resolution.path);
+      if (!conflict) continue;
+
+      if (resolution.choice === 'overwrite') {
+        const templatePath = path.join(this.templateRoot, conflict.path);
+        const localPath = path.join(this.projectRoot, '.claude', conflict.path);
+
+        const result = await merger.overwriteFile(templatePath, localPath);
+        if (result.success) {
+          applied++;
+        } else {
+          errors++;
+          console.error(chalk.red(`Error overwriting ${conflict.path}: ${result.error}`));
+        }
+      } else {
+        skipped++;
+      }
+    }
+
+    return { applied, skipped, errors };
+  }
+
+  /**
+   * Prompt for archival of removed files
+   *
+   * @param removedFiles - Array of removed file paths
+   * @returns true if user wants to archive
+   */
+  async promptArchiveRemoved(removedFiles: string[]): Promise<boolean> {
+    if (removedFiles.length === 0) {
+      return false;
+    }
+
+    console.log('');
+    console.log(chalk.yellow(`The following ${removedFiles.length} file(s) have been removed from the template:`));
+    for (const file of removedFiles.slice(0, 5)) {
+      console.log(chalk.dim(`  - ${file}`));
+    }
+    if (removedFiles.length > 5) {
+      console.log(chalk.dim(`  ... and ${removedFiles.length - 5} more`));
+    }
+    console.log('');
+
+    return await confirm({
+      message: 'Archive these files to .k0ntext/archive/ instead of deleting?',
+      default: true
+    });
+  }
+
+  /**
+   * Show dry run results
+   *
+   * @param comparisons - File comparisons
+   */
+  showDryRunResults(comparisons: FileComparison[]): void {
+    console.log('');
+    console.log(chalk.bold('Dry Run Results:\n'));
+
+    const byState = comparisons.reduce((acc, c) => {
+      acc[c.state] = acc[c.state] ?? [];
+      acc[c.state].push(c);
+      return acc;
+    }, {} as Record<string, FileComparison[]>);
+
+    const stateOrder: FileComparison['state'][] = [
+      'new',
+      'safe-update',
+      'conflict',
+      'identical',
+      'user-only',
+      'deleted'
+    ];
+
+    for (const state of stateOrder) {
+      const files = byState[state];
+      if (!files || files.length === 0) continue;
+
+      const stateLabel = this.formatState(state);
+      const icon = state === 'conflict' ? '⚠' : state === 'new' ? '+' : state === 'safe-update' ? '→' : '•';
+
+      console.log(chalk.cyan(`${icon} ${stateLabel}: ${files.length}`));
+
+      for (const file of files.slice(0, 5)) {
+        const userFlag = file.userModified ? ' [modified]' : '';
+        console.log(chalk.dim(`    ${file.path}${userFlag}`));
+      }
+
+      if (files.length > 5) {
+        console.log(chalk.dim(`    ... and ${files.length - 5} more`));
+      }
+
+      console.log('');
+    }
+  }
+}
+
+// Import path for dynamic use
+import path from 'path';