myaidev-method 0.2.24-3 → 0.2.25

package/bin/cli.js

@@ -1044,6 +1044,9 @@ program
   .option('--force', 'Force update all files without prompting')
   .option('--dry-run', 'Show what would be updated without making changes')
   .option('--verbose', 'Show detailed progress')
+  .option('--smart', 'Smart update: keep customizations, add new files (no prompts)')
+  .option('--accept-all', 'Accept all updates: replace all files (no prompts)')
+  .option('--keep-mine', 'Keep all customizations: only add new files (no prompts)')
   .action(async (options) => {
     const ora = (await import('ora')).default;
     const { fileURLToPath } = await import('url');
@@ -1056,122 +1059,128 @@ program
     try {
       const cwd = process.cwd();
 
+      // Display branding banner
+      console.log(getASCIIBanner());
+      console.log(chalk.cyan.bold('                         ⚡ Update Manager\n'));
+
       // Detect existing installation
-      console.log(chalk.cyan('\n🔍 Detecting MyAIDev Method installation...\n'));
+      const spinner = ora('Detecting MyAIDev Method installation...').start();
       const installation = await updateManager.detectExistingInstallation(cwd);
 
       if (!installation) {
-        console.log(chalk.red('❌ No MyAIDev Method installation found'));
+        spinner.fail('No MyAIDev Method installation found');
         console.log(chalk.gray('   Run: npx myaidev-method@latest init --claude'));
         process.exit(1);
       }
 
-      console.log(chalk.green(`✓ Found ${installation.type} installation`));
-      console.log(chalk.gray(`  Current version: ${installation.currentVersion}`));
+      spinner.succeed(`Found ${installation.type} installation (v${installation.currentVersion})`);
 
       // Get package version
       const packageJson = await fs.readJson(path.join(packageRoot, 'package.json'));
       const newVersion = packageJson.version;
 
-      console.log(chalk.gray(`  Latest version: ${newVersion}`));
-
       // Check if already up to date
       if (installation.currentVersion === newVersion && !options.force) {
-        console.log(chalk.green('\n✅ Already up to date!'));
+        console.log(chalk.green('\n✅ Already up to date!\n'));
         process.exit(0);
       }
 
-      if (options.dryRun) {
-        console.log(chalk.yellow('\n📋 DRY RUN MODE - No changes will be made\n'));
-      } else if (!options.force) {
-        console.log(chalk.yellow('\n⚠️  This will update your MyAIDev Method installation'));
-        console.log(chalk.gray('   Modified files will require your confirmation\n'));
+      // Generate change summary
+      const summarySpinner = ora('Analyzing changes...').start();
+      const components = ['commands', 'agents', 'scripts', 'lib', 'mcp', 'docs'];
+      const summary = await updateManager.generateChangeSummary(
+        components, cwd, installation.type, packageRoot
+      );
+      summarySpinner.succeed('Change analysis complete');
 
-        const { confirm } = await inquirer.prompt([
-          {
-            type: 'confirm',
-            name: 'confirm',
-            message: 'Continue with update?',
-            default: true
-          }
-        ]);
+      // Display summary dashboard
+      console.log('');
+      updateManager.displayChangeSummary(summary, installation.currentVersion, newVersion);
 
-        if (!confirm) {
-          console.log(chalk.gray('Update cancelled'));
-          process.exit(0);
-        }
+      // Dry run mode - just show summary and exit
+      if (options.dryRun) {
+        console.log(chalk.yellow('\n📋 DRY RUN MODE - No changes will be made\n'));
+        console.log(chalk.gray('Summary:'));
+        console.log(chalk.gray(`  • ${summary.unchanged.length} unchanged files (would skip)`));
+        console.log(chalk.gray(`  • ${summary.new.length} new files (would add)`));
+        console.log(chalk.gray(`  • ${summary.modified.length} modified files (would need decision)`));
+        console.log(chalk.gray(`  • ${summary.deleted.length} removed files (would optionally delete)`));
+        process.exit(0);
       }
 
-      // Create backup unless dry-run
-      let backupDir;
-      if (!options.dryRun) {
-        console.log(chalk.cyan('\n💾 Creating backup...'));
-        backupDir = await updateManager.createBackup(cwd, installation.type);
-        console.log(chalk.green(`✓ Backup created at: ${path.basename(backupDir)}`));
+      // Determine strategy (CLI flag or prompt)
+      let strategy;
+      if (options.smart) {
+        strategy = 'smart';
+        console.log(chalk.cyan('\n🚀 Using Smart Update strategy (--smart flag)\n'));
+      } else if (options.acceptAll) {
+        strategy = 'accept-all';
+        console.log(chalk.cyan('\n📥 Using Accept All strategy (--accept-all flag)\n'));
+      } else if (options.keepMine) {
+        strategy = 'keep-all';
+        console.log(chalk.cyan('\n🛡️  Using Keep All strategy (--keep-mine flag)\n'));
+      } else if (options.force) {
+        strategy = 'accept-all';
+        console.log(chalk.cyan('\n📥 Using Accept All strategy (--force flag)\n'));
+      } else {
+        strategy = await updateManager.promptUpdateStrategy(summary);
       }
 
-      // Update components
-      const allStats = {};
-
-      console.log(chalk.cyan('\n📦 Updating components...\n'));
-
-      // Commands
-      console.log(chalk.blue('Commands:'));
-      allStats.commands = await updateManager.updateComponent(
-        'commands', cwd, installation.type, packageRoot, options
-      );
-
-      // Agents
-      console.log(chalk.blue('\nAgents:'));
-      allStats.agents = await updateManager.updateComponent(
-        'agents', cwd, installation.type, packageRoot, options
-      );
-
-      // Scripts
-      console.log(chalk.blue('\nScripts:'));
-      allStats.scripts = await updateManager.updateComponent(
-        'scripts', cwd, installation.type, packageRoot, options
-      );
-
-      // Libraries
-      console.log(chalk.blue('\nLibraries:'));
-      allStats.lib = await updateManager.updateComponent(
-        'lib', cwd, installation.type, packageRoot, options
-      );
-
-      // MCP configurations
-      console.log(chalk.blue('\nMCP Configurations:'));
-      allStats.mcp = await updateManager.updateComponent(
-        'mcp', cwd, installation.type, packageRoot, options
-      );
-
-      // Documentation
-      console.log(chalk.blue('\nDocumentation:'));
-      allStats.docs = await updateManager.updateComponent(
-        'docs', cwd, installation.type, packageRoot, options
-      );
+      // Create timestamped backup directory
+      const backupDir = await updateManager.createTimestampedBackup(cwd, installation.type);
+
+      // Execute selected strategy
+      let results;
+      console.log(chalk.cyan('\n📦 Applying updates...\n'));
+
+      if (strategy === 'auto' || (summary.modified.length === 0)) {
+        // No conflicts - just add new files
+        results = await updateManager.executeKeepAll(summary, { verbose: options.verbose });
+      } else if (strategy === 'smart') {
+        results = await updateManager.executeSmartUpdate(summary, backupDir, { verbose: options.verbose });
+      } else if (strategy === 'accept-all') {
+        results = await updateManager.executeAcceptAll(summary, backupDir, { verbose: options.verbose });
+      } else if (strategy === 'keep-all') {
+        results = await updateManager.executeKeepAll(summary, { verbose: options.verbose });
+      } else if (strategy === 'by-category') {
+        results = await updateManager.executeCategoryUpdate(summary, backupDir, { verbose: options.verbose });
+      } else if (strategy === 'individual') {
+        // Fall back to old file-by-file for this mode
+        results = { updated: [], kept: [], added: [], backedUp: [] };
+        for (const f of summary.new) {
+          await fs.ensureDir(path.dirname(f.targetPath));
+          await fs.copy(f.sourcePath, f.targetPath);
+          results.added.push(f.file);
+          if (options.verbose) {
+            console.log(chalk.green(`  ➕ ${f.file} (new)`));
+          }
+        }
+        for (const f of summary.modified) {
+          const action = await updateManager.promptForConflict(f.file, f.targetPath, f.sourcePath);
+          if (action === 'replace') {
+            await fs.copy(f.sourcePath, f.targetPath);
+            results.updated.push(f.file);
+          } else if (action === 'backup') {
+            const backupPath = path.join(backupDir, f.componentType, f.file);
+            await fs.ensureDir(path.dirname(backupPath));
+            await fs.copy(f.targetPath, backupPath);
+            results.backedUp.push(f.file);
+            await fs.copy(f.sourcePath, f.targetPath);
+            results.updated.push(f.file);
+          } else {
+            results.kept.push(f.file);
+          }
+        }
+      }
 
       // Update dependencies
-      if (!options.dryRun) {
-        await updateManager.updateDependencies(cwd);
-      }
+      await updateManager.updateDependencies(cwd);
 
       // Save new version
-      if (!options.dryRun) {
-        await updateManager.saveVersion(cwd, installation.type, newVersion);
-      }
-
-      // Show report
-      updateManager.generateUpdateReport(allStats);
+      await updateManager.saveVersion(cwd, installation.type, newVersion);
 
-      if (options.dryRun) {
-        console.log(chalk.yellow('This was a dry run. No changes were made.'));
-      } else {
-        console.log(chalk.green(`✅ Successfully updated to v${newVersion}`));
-        if (backupDir) {
-          console.log(chalk.gray(`   Backup available at: ${path.basename(backupDir)}`));
-        }
-      }
+      // Display final results
+      updateManager.displayUpdateResults(results, backupDir, newVersion);
 
     } catch (error) {
       console.error(chalk.red('\n❌ Update failed:'));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "myaidev-method",
-  "version": "0.2.24-3",
+  "version": "0.2.25",
   "description": "Comprehensive development framework with SPARC methodology for AI-assisted software development, security testing (PTES, OWASP, penetration testing, compliance auditing), AI visual content generation (Gemini, OpenAI GPT Image 1.5, Imagen, FLUX 2, Veo 3), OpenStack VM management, multi-platform publishing (WordPress, PayloadCMS, Astro, Docusaurus, Mintlify), and Coolify deployment",
   "mcpName": "io.github.myaione/myaidev-method",
   "main": "src/index.js",

package/src/lib/update-manager.js

@@ -9,6 +9,27 @@ import { createHash } from 'crypto';
  * Handles intelligent updates with conflict resolution
  */
 
+/**
+ * Display ASCII art branding banner
+ */
+export function displayUpdateBanner() {
+  const banner = `
+${chalk.cyan('╔═══════════════════════════════════════════════════════════════════════╗')}
+${chalk.cyan('║')}                                                                       ${chalk.cyan('║')}
+${chalk.cyan('║')}  ${chalk.white.bold('███╗   ███╗██╗   ██╗ █████╗ ██╗██████╗ ███████╗██╗   ██╗')}          ${chalk.cyan('║')}
+${chalk.cyan('║')}  ${chalk.white.bold('████╗ ████║╚██╗ ██╔╝██╔══██╗██║██╔══██╗██╔════╝██║   ██║')}          ${chalk.cyan('║')}
+${chalk.cyan('║')}  ${chalk.white.bold('██╔████╔██║ ╚████╔╝ ███████║██║██║  ██║█████╗  ██║   ██║')}          ${chalk.cyan('║')}
+${chalk.cyan('║')}  ${chalk.white.bold('██║╚██╔╝██║  ╚██╔╝  ██╔══██║██║██║  ██║██╔══╝  ╚██╗ ██╔╝')}          ${chalk.cyan('║')}
+${chalk.cyan('║')}  ${chalk.white.bold('██║ ╚═╝ ██║   ██║   ██║  ██║██║██████╔╝███████╗ ╚████╔╝')}           ${chalk.cyan('║')}
+${chalk.cyan('║')}  ${chalk.white.bold('╚═╝     ╚═╝   ╚═╝   ╚═╝  ╚═╝╚═╝╚═════╝ ╚══════╝  ╚═══╝')}            ${chalk.cyan('║')}
+${chalk.cyan('║')}                                                                       ${chalk.cyan('║')}
+${chalk.cyan('║')}  ${chalk.gray('M E T H O D')}                              ${chalk.yellow('⚡ Update Manager')}         ${chalk.cyan('║')}
+${chalk.cyan('║')}                                                                       ${chalk.cyan('║')}
+${chalk.cyan('╚═══════════════════════════════════════════════════════════════════════╝')}
+`;
+  console.log(banner);
+}
+
 /**
  * Detect existing MyAIDev Method installation
  * @param {string} projectDir - Project directory path
@@ -384,3 +405,595 @@ export function generateUpdateReport(allStats) {
 
   console.log(chalk.cyan('═══════════════════════════════════════\n'));
 }
+
+/**
+ * Count lines in a file
+ * @param {string} filePath - Path to file
+ * @returns {number} Line count
+ */
+async function getLineCount(filePath) {
+  if (!await fs.pathExists(filePath)) return 0;
+  const content = await fs.readFile(filePath, 'utf-8');
+  return content.split('\n').length;
+}
+
+/**
+ * Get files for a component type
+ * @param {string} componentType - Type of component
+ * @param {string} dir - Directory to scan
+ * @returns {Array} List of files
+ */
+async function getComponentFiles(componentType, dir) {
+  if (!await fs.pathExists(dir)) return [];
+
+  if (componentType === 'docs') {
+    return ['USER_GUIDE.md', 'PUBLISHING_GUIDE.md', 'COOLIFY_DEPLOYMENT.md', 'DEV_WORKFLOW_GUIDE.md',
+            'MCP_INTEGRATION.md', 'WORDPRESS_ADMIN_SCRIPTS.md', 'TECHNICAL_ARCHITECTURE.md',
+            'WORDPRESS_INTEGRATION.md', 'wordpress-api-examples.md'];
+  }
+
+  const allFiles = await fs.readdir(dir);
+  return allFiles.filter(file => {
+    if (componentType === 'commands') return file.endsWith('.md') || file.endsWith('.toml');
+    if (componentType === 'agents') return file.endsWith('.md');
+    if (componentType === 'scripts') return file.endsWith('.js') && file !== 'init-project.js';
+    if (componentType === 'lib') return file.endsWith('.js');
+    if (componentType === 'mcp') return file.endsWith('.js') || file.endsWith('.json');
+    return true;
+  });
+}
+
+/**
+ * Generate comprehensive change summary
+ * @param {Array} components - Component types to analyze
+ * @param {string} projectDir - Project directory
+ * @param {string} cliType - CLI type (claude/gemini/codex)
+ * @param {string} sourceDir - Source package directory
+ * @returns {Object} Categorized change summary
+ */
+export async function generateChangeSummary(components, projectDir, cliType, sourceDir) {
+  const summary = {
+    unchanged: [],
+    new: [],
+    modified: [],
+    deleted: [],
+    byCategory: {}
+  };
+
+  for (const componentType of components) {
+    let targetDir, sourceSubDir;
+
+    switch (componentType) {
+      case 'commands':
+        targetDir = path.join(projectDir, `.${cliType}`, 'commands');
+        sourceSubDir = path.join(sourceDir, 'src', 'templates', cliType, 'commands');
+        break;
+      case 'agents':
+        targetDir = path.join(projectDir, `.${cliType}`, 'agents');
+        sourceSubDir = path.join(sourceDir, 'src', 'templates', 'claude', 'agents');
+        break;
+      case 'scripts':
+        targetDir = path.join(projectDir, '.myaidev-method', 'scripts');
+        sourceSubDir = path.join(sourceDir, 'src', 'scripts');
+        break;
+      case 'lib':
+        targetDir = path.join(projectDir, '.myaidev-method', 'lib');
+        sourceSubDir = path.join(sourceDir, 'src', 'lib');
+        break;
+      case 'mcp':
+        targetDir = path.join(projectDir, `.${cliType}`, 'mcp');
+        sourceSubDir = path.join(sourceDir, '.claude', 'mcp');
+        break;
+      case 'docs':
+        targetDir = projectDir;
+        sourceSubDir = sourceDir;
+        break;
+      default:
+        continue;
+    }
+
+    if (!await fs.pathExists(sourceSubDir)) continue;
+
+    summary.byCategory[componentType] = {
+      unchanged: [],
+      new: [],
+      modified: [],
+      deleted: []
+    };
+
+    const sourceFiles = await getComponentFiles(componentType, sourceSubDir);
+    const targetFiles = await getComponentFiles(componentType, targetDir);
+
+    // Check files from source (new or modified)
+    for (const file of sourceFiles) {
+      const sourcePath = path.join(sourceSubDir, file);
+      const targetPath = path.join(targetDir, file);
+
+      if (!await fs.pathExists(sourcePath)) continue;
+      const sourceStats = await fs.stat(sourcePath);
+      if (sourceStats.isDirectory()) continue;
+
+      const status = await compareFiles(targetPath, sourcePath);
+      const localLines = await getLineCount(targetPath);
+      const newLines = await getLineCount(sourcePath);
+
+      const fileInfo = {
+        file,
+        componentType,
+        sourcePath,
+        targetPath,
+        localLines,
+        newLines
+      };
+
+      if (status === 'identical') {
+        summary.unchanged.push(fileInfo);
+        summary.byCategory[componentType].unchanged.push(fileInfo);
+      } else if (status === 'new') {
+        summary.new.push(fileInfo);
+        summary.byCategory[componentType].new.push(fileInfo);
+      } else if (status === 'modified') {
+        summary.modified.push(fileInfo);
+        summary.byCategory[componentType].modified.push(fileInfo);
+      }
+    }
+
+    // Check for deleted files (in target but not in source)
+    for (const file of targetFiles) {
+      if (!sourceFiles.includes(file)) {
+        const targetPath = path.join(targetDir, file);
+        const localLines = await getLineCount(targetPath);
+        const fileInfo = {
+          file,
+          componentType,
+          sourcePath: null,
+          targetPath,
+          localLines,
+          newLines: 0
+        };
+        summary.deleted.push(fileInfo);
+        summary.byCategory[componentType].deleted.push(fileInfo);
+      }
+    }
+  }
+
+  return summary;
+}
+
+/**
+ * Display visual summary dashboard
+ * @param {Object} summary - Change summary from generateChangeSummary
+ * @param {string} currentVersion - Current installed version
+ * @param {string} newVersion - New available version
+ */
+export function displayChangeSummary(summary, currentVersion, newVersion) {
+  const boxWidth = 69;
+  const topBorder = '╔' + '═'.repeat(boxWidth) + '╗';
+  const midBorder = '╠' + '═'.repeat(boxWidth) + '╣';
+  const botBorder = '╚' + '═'.repeat(boxWidth) + '╝';
+  const innerTop = '┌' + '─'.repeat(boxWidth - 4) + '┐';
+  const innerBot = '└' + '─'.repeat(boxWidth - 4) + '┘';
+
+  console.log(chalk.cyan(topBorder));
+  console.log(chalk.cyan('║') + chalk.white.bold(`                    MyAIDev Method Update                     `.padEnd(boxWidth)) + chalk.cyan('║'));
+  console.log(chalk.cyan(midBorder));
+
+  // Version info
+  const versionLine = `  📦 Current: ${currentVersion}  →  Available: ${newVersion}`;
+  console.log(chalk.cyan('║') + chalk.white(versionLine.padEnd(boxWidth)) + chalk.cyan('║'));
+  console.log(chalk.cyan('║') + ' '.repeat(boxWidth) + chalk.cyan('║'));
+
+  // Change summary
+  console.log(chalk.cyan('║') + chalk.white.bold('  📊 CHANGE SUMMARY'.padEnd(boxWidth)) + chalk.cyan('║'));
+
+  const unchangedLine = `  ├─ ✅ Unchanged:     ${summary.unchanged.length} files (auto-skip)`;
+  const newLine = `  ├─ 🆕 New files:      ${summary.new.length} files (auto-add)`;
+  const modifiedLine = `  ├─ ⚠️  Modified:      ${summary.modified.length} files (need decision)`;
+  const deletedLine = `  └─ 🗑️  Removed:       ${summary.deleted.length} files (optional delete)`;
+
+  console.log(chalk.cyan('║') + chalk.gray(unchangedLine.padEnd(boxWidth)) + chalk.cyan('║'));
+  console.log(chalk.cyan('║') + chalk.green(newLine.padEnd(boxWidth)) + chalk.cyan('║'));
+  console.log(chalk.cyan('║') + chalk.yellow(modifiedLine.padEnd(boxWidth)) + chalk.cyan('║'));
+  console.log(chalk.cyan('║') + chalk.red(deletedLine.padEnd(boxWidth)) + chalk.cyan('║'));
+
+  // Show modified files by category if any
+  if (summary.modified.length > 0) {
+    console.log(chalk.cyan('║') + ' '.repeat(boxWidth) + chalk.cyan('║'));
+    console.log(chalk.cyan('║') + chalk.white.bold('  Modified files by category:'.padEnd(boxWidth)) + chalk.cyan('║'));
+    console.log(chalk.cyan('║') + '  ' + chalk.gray(innerTop) + chalk.cyan('║'));
+
+    for (const [category, data] of Object.entries(summary.byCategory)) {
+      if (data.modified.length === 0) continue;
+
+      const catName = category.toUpperCase();
+      const catLine = `  │ ${catName} (${data.modified.length} files)`;
+      console.log(chalk.cyan('║') + chalk.white.bold(catLine.padEnd(boxWidth)) + chalk.cyan('║'));
+
+      for (let i = 0; i < data.modified.length && i < 3; i++) {
+        const f = data.modified[i];
+        const prefix = i === data.modified.length - 1 || i === 2 ? '└─' : '├─';
+        const lineInfo = f.localLines !== f.newLines ?
+          `[${f.localLines} → ${f.newLines} lines]` : '[customized]';
+        const fileLine = `  │   ${prefix} ${f.file.slice(0, 30).padEnd(30)} ${lineInfo}`;
+        console.log(chalk.cyan('║') + chalk.gray(fileLine.padEnd(boxWidth)) + chalk.cyan('║'));
+      }
+
+      if (data.modified.length > 3) {
+        const moreLine = `  │   └─ ... (${data.modified.length - 3} more)`;
+        console.log(chalk.cyan('║') + chalk.gray(moreLine.padEnd(boxWidth)) + chalk.cyan('║'));
+      }
+
+      console.log(chalk.cyan('║') + '  │'.padEnd(boxWidth + 1) + chalk.cyan('║'));
+    }
+
+    console.log(chalk.cyan('║') + '  ' + chalk.gray(innerBot) + chalk.cyan('║'));
+  }
+
+  console.log(chalk.cyan(botBorder));
+}
+
+/**
+ * Prompt for update strategy
+ * @param {Object} summary - Change summary
+ * @returns {string} Selected strategy
+ */
+export async function promptUpdateStrategy(summary) {
+  const modifiedCount = summary.modified.length;
+
+  if (modifiedCount === 0) {
+    console.log(chalk.green('\n✓ No conflicts to resolve. All files will be updated automatically.\n'));
+    return 'auto';
+  }
+
+  console.log('');
+  const answer = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'strategy',
+      message: `How would you like to handle the ${modifiedCount} modified file${modifiedCount > 1 ? 's' : ''}?`,
+      choices: [
+        {
+          name: `🚀 Smart Update ${chalk.gray('(Recommended)')}` +
+                `\n      ${chalk.dim('Keep your customizations, add new files, backup modified')}`,
+          value: 'smart',
+          short: 'Smart Update'
+        },
+        {
+          name: '📥 Accept All Updates' +
+                `\n      ${chalk.dim('Replace all files with new versions (backups created)')}`,
+          value: 'accept-all',
+          short: 'Accept All'
+        },
+        {
+          name: '🛡️  Keep All Customizations' +
+                `\n      ${chalk.dim('Skip all modified files, only add new files')}`,
+          value: 'keep-all',
+          short: 'Keep All'
+        },
+        {
+          name: '🔍 Review Each Category' +
+                `\n      ${chalk.dim('Batch decisions per category (commands, agents, scripts)')}`,
+          value: 'by-category',
+          short: 'By Category'
+        },
+        {
+          name: '📋 Review Individual Files' +
+                `\n      ${chalk.dim(`Traditional file-by-file review (${modifiedCount} prompts)`)}`,
+          value: 'individual',
+          short: 'Individual'
+        }
+      ]
+    }
+  ]);
+
+  return answer.strategy;
+}
+
+/**
+ * Prompt for category decision
+ * @param {string} category - Category name
+ * @param {Array} files - Modified files in category
+ * @returns {string} Decision: 'keep' | 'update' | 'individual'
+ */
+export async function promptCategoryDecision(category, files) {
+  const boxWidth = 69;
+  const topBorder = '╔' + '═'.repeat(boxWidth) + '╗';
+  const midBorder = '╠' + '═'.repeat(boxWidth) + '╣';
+  const botBorder = '╚' + '═'.repeat(boxWidth) + '╝';
+
+  console.log(chalk.cyan(topBorder));
+  console.log(chalk.cyan('║') + chalk.white.bold(`  ${category.toUpperCase()} (${files.length} modified files)`.padEnd(boxWidth)) + chalk.cyan('║'));
+  console.log(chalk.cyan(midBorder));
+
+  for (let i = 0; i < files.length; i++) {
+    const f = files[i];
+    const line = `  ${i + 1}. ${f.file}`;
+    console.log(chalk.cyan('║') + chalk.white(line.padEnd(boxWidth)) + chalk.cyan('║'));
+    const infoLine = `     Your version: ${f.localLines} lines | New version: ${f.newLines} lines`;
+    console.log(chalk.cyan('║') + chalk.gray(infoLine.padEnd(boxWidth)) + chalk.cyan('║'));
+    if (i < files.length - 1) {
+      console.log(chalk.cyan('║') + ' '.repeat(boxWidth) + chalk.cyan('║'));
+    }
+  }
+
+  console.log(chalk.cyan(botBorder));
+
+  const answer = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'decision',
+      message: `What would you like to do with ${category.toUpperCase()}?`,
+      choices: [
+        { name: `Keep all my customizations (skip ${files.length} files)`, value: 'keep' },
+        { name: `Update all (replace ${files.length} files, backup originals)`, value: 'update' },
+        { name: `Review these ${files.length} files individually`, value: 'individual' }
+      ]
+    }
+  ]);
+
+  return answer.decision;
+}
+
+/**
+ * Execute smart update strategy
+ * @param {Object} summary - Change summary
+ * @param {string} backupDir - Backup directory path
+ * @param {Object} options - Update options
+ * @returns {Object} Results
+ */
+export async function executeSmartUpdate(summary, backupDir, options = {}) {
+  const results = {
+    updated: [],
+    kept: [],
+    added: [],
+    backedUp: []
+  };
+
+  // Add all new files
+  for (const f of summary.new) {
+    await fs.ensureDir(path.dirname(f.targetPath));
+    await fs.copy(f.sourcePath, f.targetPath);
+    results.added.push(f.file);
+    if (options.verbose) {
+      console.log(chalk.green(`  ➕ ${f.file} (new)`));
+    }
+  }
+
+  // Keep all modified files (smart = preserve customizations)
+  for (const f of summary.modified) {
+    // Create backup
+    const backupPath = path.join(backupDir, f.componentType, f.file);
+    await fs.ensureDir(path.dirname(backupPath));
+    await fs.copy(f.targetPath, backupPath);
+    results.backedUp.push(f.file);
+    results.kept.push(f.file);
+    if (options.verbose) {
+      console.log(chalk.gray(`  🛡️  ${f.file} (kept, backup created)`));
+    }
+  }
+
+  // Update unchanged files (they're identical so no-op, but count them)
+  results.updated = summary.unchanged.map(f => f.file);
+
+  return results;
+}
+
+/**
+ * Execute accept-all strategy
+ * @param {Object} summary - Change summary
+ * @param {string} backupDir - Backup directory path
+ * @param {Object} options - Update options
+ * @returns {Object} Results
+ */
+export async function executeAcceptAll(summary, backupDir, options = {}) {
+  const results = {
+    updated: [],
+    kept: [],
+    added: [],
+    backedUp: []
+  };
+
+  // Add all new files
+  for (const f of summary.new) {
+    await fs.ensureDir(path.dirname(f.targetPath));
+    await fs.copy(f.sourcePath, f.targetPath);
+    results.added.push(f.file);
+    if (options.verbose) {
+      console.log(chalk.green(`  ➕ ${f.file} (new)`));
+    }
+  }
+
+  // Replace all modified files with backups
+  for (const f of summary.modified) {
+    // Create backup
+    const backupPath = path.join(backupDir, f.componentType, f.file);
+    await fs.ensureDir(path.dirname(backupPath));
+    await fs.copy(f.targetPath, backupPath);
+    results.backedUp.push(f.file);
+
+    // Replace with new version
+    await fs.copy(f.sourcePath, f.targetPath);
+    results.updated.push(f.file);
+    if (options.verbose) {
+      console.log(chalk.blue(`  ✅ ${f.file} (updated, backup created)`));
+    }
+  }
+
+  return results;
+}
+
+/**
+ * Execute keep-all strategy
+ * @param {Object} summary - Change summary
+ * @param {Object} options - Update options
+ * @returns {Object} Results
+ */
+export async function executeKeepAll(summary, options = {}) {
+  const results = {
+    updated: [],
+    kept: [],
+    added: [],
+    backedUp: []
+  };
+
+  // Add all new files
+  for (const f of summary.new) {
+    await fs.ensureDir(path.dirname(f.targetPath));
+    await fs.copy(f.sourcePath, f.targetPath);
+    results.added.push(f.file);
+    if (options.verbose) {
+      console.log(chalk.green(`  ➕ ${f.file} (new)`));
+    }
+  }
+
+  // Keep all modified files
+  results.kept = summary.modified.map(f => f.file);
+  if (options.verbose) {
+    for (const f of summary.modified) {
+      console.log(chalk.gray(`  🛡️  ${f.file} (kept)`));
+    }
+  }
+
+  return results;
+}
+
+/**
+ * Execute category-based update
+ * @param {Object} summary - Change summary
+ * @param {string} backupDir - Backup directory path
+ * @param {Object} options - Update options
+ * @returns {Object} Results
+ */
+export async function executeCategoryUpdate(summary, backupDir, options = {}) {
+  const results = {
+    updated: [],
+    kept: [],
+    added: [],
+    backedUp: []
+  };
+
+  // Add all new files first
+  for (const f of summary.new) {
+    await fs.ensureDir(path.dirname(f.targetPath));
+    await fs.copy(f.sourcePath, f.targetPath);
+    results.added.push(f.file);
+    if (options.verbose) {
+      console.log(chalk.green(`  ➕ ${f.file} (new)`));
+    }
+  }
+
+  // Process each category with modified files
+  for (const [category, data] of Object.entries(summary.byCategory)) {
+    if (data.modified.length === 0) continue;
+
+    const decision = await promptCategoryDecision(category, data.modified);
+
+    if (decision === 'keep') {
+      results.kept.push(...data.modified.map(f => f.file));
+      for (const f of data.modified) {
+        if (options.verbose) {
+          console.log(chalk.gray(`  🛡️  ${f.file} (kept)`));
+        }
+      }
+    } else if (decision === 'update') {
+      for (const f of data.modified) {
+        // Create backup
+        const backupPath = path.join(backupDir, f.componentType, f.file);
+        await fs.ensureDir(path.dirname(backupPath));
+        await fs.copy(f.targetPath, backupPath);
+        results.backedUp.push(f.file);
+
+        // Replace with new version
+        await fs.copy(f.sourcePath, f.targetPath);
+        results.updated.push(f.file);
+        if (options.verbose) {
+          console.log(chalk.blue(`  ✅ ${f.file} (updated)`));
+        }
+      }
+    } else {
+      // Individual review for this category
+      for (const f of data.modified) {
+        const action = await promptForConflict(f.file, f.targetPath, f.sourcePath);
+
+        if (action === 'replace') {
+          await fs.copy(f.sourcePath, f.targetPath);
+          results.updated.push(f.file);
+        } else if (action === 'backup') {
+          const backupPath = path.join(backupDir, f.componentType, f.file);
+          await fs.ensureDir(path.dirname(backupPath));
+          await fs.copy(f.targetPath, backupPath);
+          results.backedUp.push(f.file);
+          await fs.copy(f.sourcePath, f.targetPath);
+          results.updated.push(f.file);
+        } else {
+          results.kept.push(f.file);
+        }
+      }
+    }
+  }
+
+  return results;
+}
+
+/**
+ * Display final update results
+ * @param {Object} results - Update results
+ * @param {string} backupDir - Backup directory path
+ * @param {string} newVersion - New version number
+ */
+export function displayUpdateResults(results, backupDir, newVersion) {
+  const boxWidth = 69;
+  const topBorder = '╔' + '═'.repeat(boxWidth) + '╗';
+  const midBorder = '╠' + '═'.repeat(boxWidth) + '╣';
+  const botBorder = '╚' + '═'.repeat(boxWidth) + '╝';
+
+  console.log('');
+  console.log(chalk.green(topBorder));
+  console.log(chalk.green('║') + chalk.white.bold('                     ✅ Update Complete!                        '.padEnd(boxWidth)) + chalk.green('║'));
+  console.log(chalk.green(midBorder));
+
+  console.log(chalk.green('║') + chalk.white.bold('  📊 Results:'.padEnd(boxWidth)) + chalk.green('║'));
+
+  if (results.updated.length > 0) {
+    const line = `  ├─ Updated:    ${results.updated.length} files`;
+    console.log(chalk.green('║') + chalk.blue(line.padEnd(boxWidth)) + chalk.green('║'));
+  }
+
+  if (results.kept.length > 0) {
+    const line = `  ├─ Kept:       ${results.kept.length} files (your customizations preserved)`;
+    console.log(chalk.green('║') + chalk.gray(line.padEnd(boxWidth)) + chalk.green('║'));
+  }
+
+  if (results.added.length > 0) {
+    const line = `  ├─ Added:      ${results.added.length} new files`;
+    console.log(chalk.green('║') + chalk.green(line.padEnd(boxWidth)) + chalk.green('║'));
+  }
+
+  if (results.backedUp.length > 0) {
+    const relativePath = path.relative(process.cwd(), backupDir);
+    const line = `  └─ Backed up:  ${results.backedUp.length} files → ${relativePath}/`;
+    console.log(chalk.green('║') + chalk.yellow(line.padEnd(boxWidth)) + chalk.green('║'));
+  }
+
+  console.log(chalk.green('║') + ' '.repeat(boxWidth) + chalk.green('║'));
+
+  // What's new section
+  console.log(chalk.green('║') + chalk.white.bold(`  🆕 Updated to v${newVersion}`.padEnd(boxWidth)) + chalk.green('║'));
+  console.log(chalk.green('║') + chalk.gray('  Run /myai-configure --status to see your configuration'.padEnd(boxWidth)) + chalk.green('║'));
+
+  console.log(chalk.green(botBorder));
+  console.log('');
+}
+
+/**
+ * Create timestamped backup directory
+ * @param {string} projectDir - Project directory
+ * @param {string} cliType - CLI type
+ * @returns {string} Backup directory path
+ */
+export async function createTimestampedBackup(projectDir, cliType) {
+  const date = new Date().toISOString().split('T')[0]; // YYYY-MM-DD
+  const backupDir = path.join(projectDir, `.${cliType}`, 'backups', date);
+  await fs.ensureDir(backupDir);
+  return backupDir;
+}