claude-cli-advanced-starter-pack 1.0.4 → 1.0.7

package/src/commands/setup-wizard.js

@@ -10,13 +10,27 @@ import chalk from 'chalk';
 import ora from 'ora';
 import boxen from 'boxen';
 import { existsSync, mkdirSync, writeFileSync, readFileSync, readdirSync, rmSync, renameSync, copyFileSync } from 'fs';
-import { join, basename } from 'path';
+import { join, basename, dirname } from 'path';
+import { fileURLToPath } from 'url';
 import { runInit } from './init.js';
 import { detectTechStack } from './detect-tech-stack.js';
-import { runClaudeAudit, runEnhancement } from './claude-audit.js';
+import { runEnhancement } from './claude-audit.js';
 import { runSetup as runGitHubSetup } from './setup.js';
 import { runList } from './list.js';
-import { showProjectSettingsMenu } from '../cli/menu.js';
+import {
+  performVersionCheck,
+  formatUpdateBanner,
+  loadReleaseNotes,
+  getReleasesSince,
+  getAvailableFeatures,
+  markFeatureInstalled,
+  markFeatureSkipped,
+  dismissUpdateNotification,
+  getCurrentVersion,
+} from '../utils/version-check.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
 
 /**
  * Create backup of a file before overwriting
@@ -39,15 +53,189 @@ export function createBackup(filePath) {
   return backupPath;
 }
 
+/**
+ * Find existing CCASP backups in the project
+ */
+function findExistingBackups() {
+  const backupDir = join(process.cwd(), '.claude-backup');
+  const backups = [];
+
+  if (!existsSync(backupDir)) {
+    return backups;
+  }
+
+  try {
+    const entries = readdirSync(backupDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        const backupPath = join(backupDir, entry.name);
+        const hasClaudeDir = existsSync(join(backupPath, '.claude'));
+        const hasClaudeMd = existsSync(join(backupPath, 'CLAUDE.md'));
+
+        if (hasClaudeDir || hasClaudeMd) {
+          // Parse timestamp from folder name (format: 2025-01-30T12-30-45)
+          let date = entry.name;
+          try {
+            const isoDate = entry.name.replace(/T(\d{2})-(\d{2})-(\d{2})/, 'T$1:$2:$3');
+            date = new Date(isoDate).toLocaleString();
+          } catch {
+            // Keep original name if parsing fails
+          }
+
+          backups.push({
+            name: entry.name,
+            path: backupPath,
+            date,
+            hasClaudeDir,
+            hasClaudeMd,
+          });
+        }
+      }
+    }
+  } catch {
+    // Silently fail
+  }
+
+  // Sort by name (newest first)
+  return backups.sort((a, b) => b.name.localeCompare(a.name));
+}
+
+/**
+ * Restore from a backup
+ */
+async function runRestore(backups) {
+  if (backups.length === 0) {
+    console.log(chalk.yellow('\n⚠️  No backups found in .claude-backup/\n'));
+    return false;
+  }
+
+  console.log(chalk.bold('\n📦 Available backups:\n'));
+
+  const choices = backups.map((backup, index) => {
+    const contents = [];
+    if (backup.hasClaudeDir) contents.push('.claude/');
+    if (backup.hasClaudeMd) contents.push('CLAUDE.md');
+
+    return {
+      name: `${chalk.yellow(`${index + 1}.`)} ${backup.date} ${chalk.dim(`(${contents.join(', ')})`)}`,
+      value: backup,
+      short: backup.date,
+    };
+  });
+
+  choices.push({
+    name: `${chalk.green('0.')} Cancel`,
+    value: null,
+    short: 'Cancel',
+  });
+
+  const { selectedBackup } = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'selectedBackup',
+      message: 'Select a backup to restore:',
+      choices,
+    },
+  ]);
+
+  if (!selectedBackup) {
+    console.log(chalk.dim('\nCancelled. No changes made.\n'));
+    return false;
+  }
+
+  // Confirm restore
+  const claudeDir = join(process.cwd(), '.claude');
+  const claudeMdPath = join(process.cwd(), 'CLAUDE.md');
+  const willOverwrite = [];
+
+  if (existsSync(claudeDir) && selectedBackup.hasClaudeDir) {
+    willOverwrite.push('.claude/');
+  }
+  if (existsSync(claudeMdPath) && selectedBackup.hasClaudeMd) {
+    willOverwrite.push('CLAUDE.md');
+  }
+
+  if (willOverwrite.length > 0) {
+    console.log(chalk.yellow(`\n⚠️  This will overwrite: ${willOverwrite.join(', ')}`));
+  }
+
+  const { confirmRestore } = await inquirer.prompt([
+    {
+      type: 'confirm',
+      name: 'confirmRestore',
+      message: `Restore from backup "${selectedBackup.date}"?`,
+      default: true,
+    },
+  ]);
+
+  if (!confirmRestore) {
+    console.log(chalk.dim('\nCancelled. No changes made.\n'));
+    return false;
+  }
+
+  const spinner = ora('Restoring from backup...').start();
+
+  try {
+    // Restore .claude folder
+    if (selectedBackup.hasClaudeDir) {
+      const backupClaudeDir = join(selectedBackup.path, '.claude');
+      if (existsSync(claudeDir)) {
+        rmSync(claudeDir, { recursive: true, force: true });
+      }
+      copyDirRecursive(backupClaudeDir, claudeDir);
+      spinner.text = 'Restored .claude folder...';
+    }
+
+    // Restore CLAUDE.md
+    if (selectedBackup.hasClaudeMd) {
+      const backupClaudeMd = join(selectedBackup.path, 'CLAUDE.md');
+      copyFileSync(backupClaudeMd, claudeMdPath);
+      spinner.text = 'Restored CLAUDE.md...';
+    }
+
+    spinner.succeed('Backup restored successfully!');
+
+    console.log(
+      boxen(
+        chalk.green('✅ Restored from backup\n\n') +
+          `Backup date: ${chalk.cyan(selectedBackup.date)}\n` +
+          (selectedBackup.hasClaudeDir ? `  • ${chalk.cyan('.claude/')} restored\n` : '') +
+          (selectedBackup.hasClaudeMd ? `  • ${chalk.cyan('CLAUDE.md')} restored\n` : '') +
+          '\n' +
+          chalk.dim('Restart Claude Code CLI to use restored configuration.'),
+        {
+          padding: 1,
+          borderStyle: 'round',
+          borderColor: 'green',
+        }
+      )
+    );
+
+    return true;
+  } catch (error) {
+    spinner.fail('Restore failed');
+    console.error(chalk.red(error.message));
+    return false;
+  }
+}
+
 /**
  * Remove CCASP from a project
  */
 async function runRemove() {
   const claudeDir = join(process.cwd(), '.claude');
+  const claudeMdPath = join(process.cwd(), 'CLAUDE.md');
+  const existingBackups = findExistingBackups();
 
-  if (!existsSync(claudeDir)) {
+  // Check if there's anything to work with
+  const hasClaudeDir = existsSync(claudeDir);
+  const hasClaudeMd = existsSync(claudeMdPath);
+
+  if (!hasClaudeDir && existingBackups.length === 0) {
     console.log(chalk.yellow('\n⚠️  No .claude folder found in this project.\n'));
-    return false;
+    if (!hasClaudeMd) {
+      return false;
+    }
   }
 
   // Show what will be removed
@@ -112,41 +300,67 @@ async function runRemove() {
     }
   }
 
-  if (itemsToRemove.length === 0) {
+  // Check for CLAUDE.md in project root
+  if (hasClaudeMd) {
+    console.log(`  ${chalk.cyan('CLAUDE.md')} ${chalk.dim('(project root)')}`);
+    itemsToRemove.push({ type: 'file', path: claudeMdPath, label: 'CLAUDE.md', isRoot: true });
+  }
+
+  if (itemsToRemove.length === 0 && existingBackups.length === 0) {
     console.log(chalk.yellow('  No CCASP items found.\n'));
     return false;
   }
 
+  // Show existing backups count
+  if (existingBackups.length > 0) {
+    console.log(chalk.dim(`\n  📦 ${existingBackups.length} backup(s) available in .claude-backup/`));
+  }
+
   console.log('');
 
-  // Removal options
+  // Removal options - dynamically build based on what exists
+  const removeChoices = [];
+
+  if (itemsToRemove.length > 0) {
+    removeChoices.push(
+      {
+        name: `${chalk.red('1.')} Remove ALL ${chalk.dim('- Delete .claude/ and CLAUDE.md')}`,
+        value: 'all',
+        short: 'Remove All',
+      },
+      {
+        name: `${chalk.yellow('2.')} Remove with backup ${chalk.dim('- Full backup to .claude-backup/ first')}`,
+        value: 'backup',
+        short: 'Backup & Remove',
+      },
+      {
+        name: `${chalk.cyan('3.')} Selective removal ${chalk.dim('- Choose what to remove')}`,
+        value: 'selective',
+        short: 'Selective',
+      }
+    );
+  }
+
+  if (existingBackups.length > 0) {
+    removeChoices.push({
+      name: `${chalk.green('4.')} Restore from backup ${chalk.dim(`- ${existingBackups.length} backup(s) available`)}`,
+      value: 'restore',
+      short: 'Restore',
+    });
+  }
+
+  removeChoices.push({
+    name: `${chalk.dim('0.')} Cancel ${chalk.dim('- Keep everything')}`,
+    value: 'cancel',
+    short: 'Cancel',
+  });
+
   const { removeAction } = await inquirer.prompt([
     {
       type: 'list',
       name: 'removeAction',
       message: 'What would you like to do?',
-      choices: [
-        {
-          name: `${chalk.red('1.')} Remove ALL ${chalk.dim('- Delete entire .claude folder')}`,
-          value: 'all',
-          short: 'Remove All',
-        },
-        {
-          name: `${chalk.yellow('2.')} Remove with backup ${chalk.dim('- Backup to .claude-backup/ first')}`,
-          value: 'backup',
-          short: 'Backup & Remove',
-        },
-        {
-          name: `${chalk.cyan('3.')} Selective removal ${chalk.dim('- Choose what to remove')}`,
-          value: 'selective',
-          short: 'Selective',
-        },
-        {
-          name: `${chalk.green('0.')} Cancel ${chalk.dim('- Keep everything')}`,
-          value: 'cancel',
-          short: 'Cancel',
-        },
-      ],
+      choices: removeChoices,
     },
   ]);
 
@@ -155,6 +369,11 @@ async function runRemove() {
     return false;
   }
 
+  // Handle restore action
+  if (removeAction === 'restore') {
+    return await runRestore(existingBackups);
+  }
+
   if (removeAction === 'backup' || removeAction === 'all') {
     // Confirm dangerous action
     const { confirmRemove } = await inquirer.prompt([
@@ -176,24 +395,49 @@ async function runRemove() {
 
   try {
     if (removeAction === 'backup') {
-      // Create backup first
-      const backupDir = join(process.cwd(), '.claude-backup', new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19));
+      // Create backup first - include timestamp folder
+      const timestamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);
+      const backupDir = join(process.cwd(), '.claude-backup', timestamp);
       mkdirSync(backupDir, { recursive: true });
 
-      // Copy entire .claude folder to backup
-      copyDirRecursive(claudeDir, backupDir);
+      // Copy entire .claude folder to backup (nested under .claude/)
+      if (hasClaudeDir) {
+        const backupClaudeDir = join(backupDir, '.claude');
+        copyDirRecursive(claudeDir, backupClaudeDir);
+        spinner.text = 'Backed up .claude folder...';
+      }
+
+      // Also backup CLAUDE.md if it exists
+      if (hasClaudeMd) {
+        copyFileSync(claudeMdPath, join(backupDir, 'CLAUDE.md'));
+        spinner.text = 'Backed up CLAUDE.md...';
+      }
+
       spinner.succeed(`Backed up to ${chalk.cyan(backupDir)}`);
 
-      // Then remove
-      spinner.start('Removing .claude folder...');
-      rmSync(claudeDir, { recursive: true, force: true });
-      spinner.succeed('.claude folder removed');
+      // Then remove .claude folder
+      if (hasClaudeDir) {
+        spinner.start('Removing .claude folder...');
+        rmSync(claudeDir, { recursive: true, force: true });
+        spinner.succeed('.claude folder removed');
+      }
+
+      // Remove CLAUDE.md
+      if (hasClaudeMd) {
+        spinner.start('Removing CLAUDE.md...');
+        rmSync(claudeMdPath, { force: true });
+        spinner.succeed('CLAUDE.md removed');
+      }
 
       console.log(
         boxen(
-          chalk.green('✅ CCASP removed with backup\n\n') +
+          chalk.green('✅ CCASP removed with full backup\n\n') +
             `Backup location:\n${chalk.cyan(backupDir)}\n\n` +
-            chalk.dim('To restore: copy backup contents to .claude/'),
+            chalk.bold('Contents backed up:\n') +
+            (hasClaudeDir ? `  • ${chalk.cyan('.claude/')} folder\n` : '') +
+            (hasClaudeMd ? `  • ${chalk.cyan('CLAUDE.md')} file\n` : '') +
+            '\n' +
+            chalk.dim('To restore: run ') + chalk.cyan('ccasp wizard') + chalk.dim(' → Remove CCASP → Restore'),
           {
             padding: 1,
             borderStyle: 'round',
@@ -203,12 +447,22 @@ async function runRemove() {
       );
     } else if (removeAction === 'all') {
       // Remove without backup
-      rmSync(claudeDir, { recursive: true, force: true });
-      spinner.succeed('.claude folder removed');
+      if (hasClaudeDir) {
+        rmSync(claudeDir, { recursive: true, force: true });
+        spinner.text = '.claude folder removed...';
+      }
+
+      if (hasClaudeMd) {
+        rmSync(claudeMdPath, { force: true });
+        spinner.text = 'CLAUDE.md removed...';
+      }
+
+      spinner.succeed('CCASP files removed');
 
       console.log(
         boxen(
           chalk.green('✅ CCASP removed\n\n') +
+            chalk.yellow('⚠️  No backup was created.\n\n') +
             chalk.dim('Run ') + chalk.cyan('ccasp wizard') + chalk.dim(' to set up again.'),
           {
             padding: 1,
@@ -226,8 +480,8 @@ async function runRemove() {
           type: 'checkbox',
           name: 'itemsToDelete',
           message: 'Select items to remove:',
-          choices: itemsToRemove.map(item => ({
-            name: item.label,
+          choices: itemsToRemove.map((item) => ({
+            name: item.isRoot ? `${item.label} ${chalk.dim('(project root)')}` : item.label,
             value: item,
             checked: false,
           })),
@@ -239,22 +493,44 @@ async function runRemove() {
         return false;
       }
 
-      // Create backups for selected items
-      const backupDir = join(process.cwd(), '.claude', 'backups', new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19));
-      mkdirSync(backupDir, { recursive: true });
+      // Create backups for selected items in .claude-backup/ (not .claude/backups/)
+      // This ensures backups survive if user removes entire .claude folder
+      const timestamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);
+      const backupDir = join(process.cwd(), '.claude-backup', `selective-${timestamp}`);
+      const backupClaudeDir = join(backupDir, '.claude');
+      mkdirSync(backupClaudeDir, { recursive: true });
 
       for (const item of itemsToDelete) {
+        // Determine backup destination - CLAUDE.md goes to backup root, others under .claude/
+        const backupDest = item.isRoot ? join(backupDir, basename(item.path)) : join(backupClaudeDir, basename(item.path));
+
         if (item.type === 'dir') {
-          copyDirRecursive(item.path, join(backupDir, basename(item.path)));
+          copyDirRecursive(item.path, backupDest);
           rmSync(item.path, { recursive: true, force: true });
         } else {
-          copyFileSync(item.path, join(backupDir, basename(item.path)));
+          // Ensure parent directory exists
+          const parentDir = dirname(backupDest);
+          if (!existsSync(parentDir)) {
+            mkdirSync(parentDir, { recursive: true });
+          }
+          copyFileSync(item.path, backupDest);
           rmSync(item.path, { force: true });
         }
         console.log(`  ${chalk.red('✗')} Removed ${item.label}`);
       }
 
-      console.log(chalk.dim(`\nBackups saved to: ${backupDir}\n`));
+      console.log(
+        boxen(
+          chalk.green('✅ Selected items removed\n\n') +
+            `Backup location:\n${chalk.cyan(backupDir)}\n\n` +
+            chalk.dim('To restore: run ') + chalk.cyan('ccasp wizard') + chalk.dim(' → Remove CCASP → Restore'),
+          {
+            padding: 1,
+            borderStyle: 'round',
+            borderColor: 'green',
+          }
+        )
+      );
     }
 
     return true;
@@ -321,32 +597,17 @@ const SETUP_OPTIONS = [
     short: 'GitHub',
   },
   {
-    name: `${chalk.yellow('4.')} Audit CLAUDE.md ${chalk.dim('- Check existing config')}`,
-    value: 'audit',
-    short: 'Audit',
-  },
-  {
-    name: `${chalk.yellow('5.')} Enhance CLAUDE.md ${chalk.dim('- Generate/improve docs')}`,
-    value: 'enhance',
-    short: 'Enhance',
-  },
-  {
-    name: `${chalk.yellow('6.')} Detect Tech Stack ${chalk.dim('- Auto-detect project')}`,
-    value: 'detect',
-    short: 'Detect',
-  },
-  {
-    name: `${chalk.yellow('7.')} View Templates ${chalk.dim('- Browse available items')}`,
+    name: `${chalk.yellow('4.')} View Templates ${chalk.dim('- Browse available items')}`,
     value: 'templates',
     short: 'Templates',
   },
   {
-    name: `${chalk.yellow('8.')} Project Settings ${chalk.dim('- Configure deployment, tunnels, etc.')}`,
-    value: 'settings',
-    short: 'Settings',
+    name: `${chalk.yellow('5.')} Prior Releases ${chalk.dim('- Review & add features from past versions')}`,
+    value: 'releases',
+    short: 'Releases',
   },
   {
-    name: `${chalk.yellow('9.')} Remove CCASP ${chalk.dim('- Uninstall from this project')}`,
+    name: `${chalk.yellow('6.')} Remove CCASP ${chalk.dim('- Uninstall from this project')}`,
     value: 'remove',
     short: 'Remove',
   },
@@ -618,12 +879,407 @@ async function showTemplates() {
   }
 }
 
+/**
+ * Show prior releases and allow adding features
+ */
+async function showPriorReleases() {
+  console.log(chalk.bold('\n📜 Prior Releases\n'));
+
+  const { releases } = loadReleaseNotes();
+  const currentVersion = getCurrentVersion();
+
+  if (!releases || releases.length === 0) {
+    console.log(chalk.yellow('  No release history available.\n'));
+    return;
+  }
+
+  // Show release list
+  console.log(chalk.dim('  Select a release to view details and available features:\n'));
+
+  releases.forEach((release, i) => {
+    const isCurrent = release.version === currentVersion;
+    const marker = isCurrent ? chalk.green('●') : chalk.dim('○');
+    const currentLabel = isCurrent ? chalk.green(' (current)') : '';
+    console.log(`  ${chalk.yellow(i + 1 + '.')} ${marker} v${release.version}${currentLabel} ${chalk.dim(`(${release.date})`)}`);
+    console.log(`     ${chalk.dim(release.summary)}`);
+  });
+
+  console.log('');
+
+  const { releaseChoice } = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'releaseChoice',
+      message: 'Select a release to view details:',
+      choices: [
+        ...releases.map((r, i) => ({
+          name: `${i + 1}. v${r.version} - ${r.summary}`,
+          value: i,
+          short: `v${r.version}`,
+        })),
+        {
+          name: `${chalk.cyan('A.')} Add available features to project`,
+          value: 'add',
+          short: 'Add Features',
+        },
+        {
+          name: `${chalk.dim('0.')} Back to menu`,
+          value: 'back',
+          short: 'Back',
+        },
+      ],
+      pageSize: 12,
+    },
+  ]);
+
+  if (releaseChoice === 'back') {
+    return;
+  }
+
+  if (releaseChoice === 'add') {
+    await showAddFeaturesMenu();
+    return;
+  }
+
+  // Show release details
+  const release = releases[releaseChoice];
+  await showReleaseDetails(release);
+}
+
+/**
+ * Show detailed release information
+ */
+async function showReleaseDetails(release) {
+  console.log(
+    boxen(
+      chalk.bold.cyan(`v${release.version}\n`) +
+        chalk.dim(`Released: ${release.date}\n\n`) +
+        chalk.white(release.summary),
+      {
+        padding: 1,
+        borderStyle: 'round',
+        borderColor: 'cyan',
+        title: '📦 Release Details',
+        titleAlignment: 'center',
+      }
+    )
+  );
+
+  // Show highlights
+  if (release.highlights && release.highlights.length > 0) {
+    console.log(chalk.bold('\n✨ Highlights:\n'));
+    release.highlights.forEach((h) => {
+      console.log(`  • ${h}`);
+    });
+  }
+
+  // Show new features
+  if (release.newFeatures) {
+    const { commands, agents, skills, hooks, other } = release.newFeatures;
+
+    if (commands && commands.length > 0) {
+      console.log(chalk.bold('\n📝 New Commands:\n'));
+      commands.forEach((cmd) => {
+        console.log(`  ${chalk.cyan(`/${cmd.name}`)} - ${cmd.description}`);
+      });
+    }
+
+    if (agents && agents.length > 0) {
+      console.log(chalk.bold('\n🤖 New Agents:\n'));
+      agents.forEach((agent) => {
+        console.log(`  ${chalk.cyan(agent.name)} - ${agent.description}`);
+      });
+    }
+
+    if (skills && skills.length > 0) {
+      console.log(chalk.bold('\n🎯 New Skills:\n'));
+      skills.forEach((skill) => {
+        console.log(`  ${chalk.cyan(skill.name)} - ${skill.description}`);
+      });
+    }
+
+    if (hooks && hooks.length > 0) {
+      console.log(chalk.bold('\n🪝 New Hooks:\n'));
+      hooks.forEach((hook) => {
+        console.log(`  ${chalk.cyan(hook.name)} - ${hook.description}`);
+      });
+    }
+
+    if (other && other.length > 0) {
+      console.log(chalk.bold('\n🔧 Other Improvements:\n'));
+      other.forEach((item) => {
+        console.log(`  ${chalk.cyan(item.name)} - ${item.description}`);
+      });
+    }
+  }
+
+  // Show breaking changes
+  if (release.breaking && release.breaking.length > 0) {
+    console.log(chalk.bold.red('\n⚠️  Breaking Changes:\n'));
+    release.breaking.forEach((b) => {
+      console.log(`  ${chalk.red('!')} ${b}`);
+    });
+  }
+
+  console.log('');
+
+  // Offer to add features from this release
+  const hasNewFeatures =
+    release.newFeatures &&
+    (release.newFeatures.commands?.length > 0 ||
+      release.newFeatures.agents?.length > 0 ||
+      release.newFeatures.skills?.length > 0 ||
+      release.newFeatures.hooks?.length > 0);
+
+  if (hasNewFeatures) {
+    const { addFeatures } = await inquirer.prompt([
+      {
+        type: 'confirm',
+        name: 'addFeatures',
+        message: 'Would you like to add features from this release to your project?',
+        default: false,
+      },
+    ]);
+
+    if (addFeatures) {
+      await addFeaturesFromRelease(release);
+    }
+  }
+}
+
+/**
+ * Show menu to add available features
+ */
+async function showAddFeaturesMenu() {
+  const claudeDir = join(process.cwd(), '.claude');
+  const commandsDir = join(claudeDir, 'commands');
+
+  if (!existsSync(claudeDir)) {
+    console.log(chalk.yellow('\n⚠️  No .claude folder found. Run Quick Start (1) or Full Setup (2) first.\n'));
+    return;
+  }
+
+  // Get existing commands
+  const existingCommands = existsSync(commandsDir)
+    ? readdirSync(commandsDir).filter((f) => f.endsWith('.md') && f !== 'INDEX.md' && f !== 'README.md').map((f) => f.replace('.md', ''))
+    : [];
+
+  // Get all available features from releases
+  const { releases, featureRegistry } = loadReleaseNotes();
+
+  if (!featureRegistry || !featureRegistry.commands) {
+    console.log(chalk.yellow('\n  No feature registry available.\n'));
+    return;
+  }
+
+  // Find commands not yet installed
+  const availableCommands = Object.entries(featureRegistry.commands)
+    .filter(([name, info]) => !existingCommands.includes(name) && !info.required)
+    .map(([name, info]) => {
+      // Find description from releases
+      let description = 'No description available';
+      for (const release of releases) {
+        const cmd = release.newFeatures?.commands?.find((c) => c.name === name);
+        if (cmd) {
+          description = cmd.description;
+          break;
+        }
+      }
+      return { name, description, addedIn: info.addedIn };
+    });
+
+  if (availableCommands.length === 0) {
+    console.log(chalk.green('\n✓ All available commands are already installed!\n'));
+    return;
+  }
+
+  console.log(chalk.bold('\n📦 Available Commands to Add:\n'));
+  console.log(chalk.dim('  Select commands to add to your project:\n'));
+
+  const { selectedCommands } = await inquirer.prompt([
+    {
+      type: 'checkbox',
+      name: 'selectedCommands',
+      message: 'Select commands to install:',
+      choices: availableCommands.map((cmd) => ({
+        name: `/${cmd.name} - ${cmd.description} ${chalk.dim(`(v${cmd.addedIn})`)}`,
+        value: cmd.name,
+        checked: false,
+      })),
+      pageSize: 15,
+    },
+  ]);
+
+  if (selectedCommands.length === 0) {
+    console.log(chalk.dim('\n  No commands selected.\n'));
+    return;
+  }
+
+  // Install selected commands
+  const spinner = ora('Installing commands...').start();
+  const installed = [];
+  const failed = [];
+
+  for (const cmdName of selectedCommands) {
+    try {
+      // Look for template file
+      const templatePath = join(__dirname, '..', '..', 'templates', 'commands', `${cmdName}.template.md`);
+
+      if (existsSync(templatePath)) {
+        const content = readFileSync(templatePath, 'utf8');
+        const cmdPath = join(commandsDir, `${cmdName}.md`);
+        writeFileSync(cmdPath, content, 'utf8');
+        installed.push(cmdName);
+        markFeatureInstalled(cmdName);
+      } else {
+        failed.push({ name: cmdName, error: 'Template not found' });
+      }
+    } catch (error) {
+      failed.push({ name: cmdName, error: error.message });
+    }
+  }
+
+  spinner.stop();
+
+  if (installed.length > 0) {
+    console.log(chalk.green(`\n✓ Installed ${installed.length} command(s):`));
+    installed.forEach((cmd) => {
+      console.log(`  ${chalk.cyan(`/${cmd}`)}`);
+    });
+  }
+
+  if (failed.length > 0) {
+    console.log(chalk.red(`\n✗ Failed to install ${failed.length} command(s):`));
+    failed.forEach((f) => {
+      console.log(`  ${chalk.red(`/${f.name}`)}: ${f.error}`);
+    });
+  }
+
+  if (installed.length > 0) {
+    showRestartReminder();
+  }
+}
+
+/**
+ * Add features from a specific release
+ */
+async function addFeaturesFromRelease(release) {
+  const claudeDir = join(process.cwd(), '.claude');
+  const commandsDir = join(claudeDir, 'commands');
+
+  if (!existsSync(claudeDir)) {
+    console.log(chalk.yellow('\n⚠️  No .claude folder found. Run Quick Start (1) or Full Setup (2) first.\n'));
+    return;
+  }
+
+  if (!release.newFeatures?.commands || release.newFeatures.commands.length === 0) {
+    console.log(chalk.yellow('\n  No commands to add from this release.\n'));
+    return;
+  }
+
+  // Get existing commands
+  const existingCommands = existsSync(commandsDir)
+    ? readdirSync(commandsDir).filter((f) => f.endsWith('.md')).map((f) => f.replace('.md', ''))
+    : [];
+
+  // Filter to commands not yet installed
+  const availableCommands = release.newFeatures.commands.filter((cmd) => !existingCommands.includes(cmd.name));
+
+  if (availableCommands.length === 0) {
+    console.log(chalk.green('\n✓ All commands from this release are already installed!\n'));
+    return;
+  }
+
+  const { selectedCommands } = await inquirer.prompt([
+    {
+      type: 'checkbox',
+      name: 'selectedCommands',
+      message: 'Select commands to install:',
+      choices: availableCommands.map((cmd) => ({
+        name: `/${cmd.name} - ${cmd.description}`,
+        value: cmd.name,
+        checked: true,
+      })),
+      pageSize: 10,
+    },
+  ]);
+
+  if (selectedCommands.length === 0) {
+    console.log(chalk.dim('\n  No commands selected.\n'));
+    return;
+  }
+
+  // Install selected commands
+  const spinner = ora('Installing commands...').start();
+  const installed = [];
+  const failed = [];
+
+  for (const cmdName of selectedCommands) {
+    try {
+      const templatePath = join(__dirname, '..', '..', 'templates', 'commands', `${cmdName}.template.md`);
+
+      if (existsSync(templatePath)) {
+        const content = readFileSync(templatePath, 'utf8');
+        const cmdPath = join(commandsDir, `${cmdName}.md`);
+        writeFileSync(cmdPath, content, 'utf8');
+        installed.push(cmdName);
+        markFeatureInstalled(cmdName);
+      } else {
+        failed.push({ name: cmdName, error: 'Template not found' });
+      }
+    } catch (error) {
+      failed.push({ name: cmdName, error: error.message });
+    }
+  }
+
+  spinner.stop();
+
+  if (installed.length > 0) {
+    console.log(chalk.green(`\n✓ Installed ${installed.length} command(s):`));
+    installed.forEach((cmd) => {
+      console.log(`  ${chalk.cyan(`/${cmd}`)}`);
+    });
+    showRestartReminder();
+  }
+
+  if (failed.length > 0) {
+    console.log(chalk.red(`\n✗ Failed to install ${failed.length} command(s):`));
+    failed.forEach((f) => {
+      console.log(`  ${chalk.red(`/${f.name}`)}: ${f.error}`);
+    });
+  }
+}
+
+/**
+ * Check for updates and show banner if available
+ */
+async function checkAndShowUpdateBanner() {
+  try {
+    const checkResult = await performVersionCheck(process.cwd(), false);
+
+    if (checkResult.updateAvailable && checkResult.shouldNotify) {
+      const banner = formatUpdateBanner(checkResult);
+      if (banner) {
+        console.log(chalk.yellow(banner));
+      }
+    }
+
+    return checkResult;
+  } catch {
+    // Silently fail - network might be unavailable
+    return null;
+  }
+}
+
 /**
  * Main setup wizard - entry point
  */
 export async function runSetupWizard(options = {}) {
   showSetupHeader();
 
+  // Check for updates in background (non-blocking display)
+  await checkAndShowUpdateBanner();
+
   // Check if .claude already exists
   const claudeDir = join(process.cwd(), '.claude');
   const claudeMd = join(process.cwd(), 'CLAUDE.md');
@@ -644,7 +1300,7 @@ export async function runSetupWizard(options = {}) {
         name: 'action',
         message: 'What would you like to do?',
         choices: SETUP_OPTIONS,
-        pageSize: 10,
+        pageSize: 12,
       },
     ]);
 
@@ -666,44 +1322,12 @@ export async function runSetupWizard(options = {}) {
         showRestartReminder();
         break;
 
-      case 'audit':
-        await runClaudeAudit();
-        // Audit doesn't modify files, no restart needed
-        break;
-
-      case 'enhance':
-        await runEnhancement();
-        // Enhancement modifies CLAUDE.md which requires restart
-        showRestartReminder();
-        break;
-
-      case 'detect':
-        const spinner = ora('Detecting tech stack...').start();
-        try {
-          const techStack = await detectTechStack(process.cwd());
-          spinner.succeed('Detection complete!');
-          console.log(chalk.bold('\nDetected Tech Stack:'));
-          console.log(JSON.stringify(techStack, null, 2));
-        } catch (error) {
-          spinner.fail('Detection failed');
-          console.error(chalk.red(error.message));
-        }
-        console.log('');
-        break;
-
       case 'templates':
         await showTemplates();
         break;
 
-      case 'settings':
-        // Check if .claude folder exists first
-        if (!existsSync(join(process.cwd(), '.claude'))) {
-          console.log(chalk.yellow('\n⚠️  No .claude folder found. Run Quick Start (1) or Full Setup (2) first.\n'));
-        } else {
-          await showProjectSettingsMenu();
-          // Settings modify tech-stack.json which may require restart
-          showRestartReminder();
-        }
+      case 'releases':
+        await showPriorReleases();
         break;
 
       case 'remove':
@@ -733,8 +1357,6 @@ Run the Claude CLI Advanced Starter Pack setup wizard.
 
 This command launches the interactive setup wizard for configuring:
 - .claude folder structure
-- CLAUDE.md generation
-- Tech stack detection
 - GitHub project integration
 - Agents, hooks, and skills
 
@@ -744,10 +1366,14 @@ Reply with a number to jump to that option:
 1. Quick Start - Auto-detect and initialize
 2. Full Setup - All features with customization
 3. GitHub Setup - Connect to project board
-4. Audit - Check existing CLAUDE.md
-5. Enhance - Generate/improve CLAUDE.md
-6. Detect - Show detected tech stack
-7. Templates - Browse available templates
+4. View Templates - Browse available templates
+5. Prior Releases - Review & add features from past versions
+6. Remove CCASP - Uninstall from this project
+
+## Related Commands
+
+- \`/project-impl\` - Agent-powered project implementation (audit, enhance, detect, configure)
+- \`/update-check\` - Check for updates and add new features
 
 ## From Terminal