claude-cli-advanced-starter-pack 1.0.2 → 1.0.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-cli-advanced-starter-pack",
-  "version": "1.0.2",
+  "version": "1.0.3",
   "description": "Advanced Claude Code CLI toolkit - agents, hooks, skills, MCP servers, phased development, and GitHub integration",
   "main": "src/index.js",
   "bin": {

package/src/commands/init.js

@@ -14,6 +14,7 @@ import { join, dirname, basename } from 'path';
 import { fileURLToPath } from 'url';
 import { showHeader, showSuccess, showError, showWarning, showInfo } from '../cli/menu.js';
 import { getVersion } from '../utils.js';
+import { createBackup } from './setup-wizard.js';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
@@ -1528,7 +1529,8 @@ export async function runInit(options = {}) {
         message: 'How would you like to handle existing commands?',
         choices: [
           { name: 'Skip existing - only install new commands (recommended)', value: 'skip' },
-          { name: 'Overwrite all - replace existing with starter pack versions', value: 'overwrite' },
+          { name: 'Overwrite with backup - save existing to .claude/backups/ first', value: 'backup' },
+          { name: 'Overwrite all - replace existing (no backup)', value: 'overwrite' },
           { name: 'Cancel installation', value: 'cancel' },
         ],
       },
@@ -1539,7 +1541,8 @@ export async function runInit(options = {}) {
       return;
     }
 
-    overwrite = overwriteChoice === 'overwrite';
+    overwrite = overwriteChoice === 'overwrite' || overwriteChoice === 'backup';
+    const createBackups = overwriteChoice === 'backup';
 
     if (!overwrite) {
       // Filter out existing commands (keep only new ones + required)
@@ -1547,11 +1550,17 @@ export async function runInit(options = {}) {
       finalCommands.length = 0;
       finalCommands.push(...filtered);
       console.log(chalk.green(`\n  ✓ Will install ${finalCommands.length} new command(s), preserving ${commandsToOverwrite.length} existing`));
+    } else if (createBackups) {
+      console.log(chalk.cyan(`\n  ✓ Will backup and overwrite ${commandsToOverwrite.length} existing command(s)`));
     } else {
       console.log(chalk.yellow(`\n  ⚠ Will overwrite ${commandsToOverwrite.length} existing command(s)`));
     }
   }
 
+  // Track if we should create backups (set outside the if block for use later)
+  const createBackups = options.backup || (typeof overwrite !== 'undefined' && commandsToOverwrite.length > 0 && !options.force);
+  let backedUpFiles = [];
+
   // Step 7: Install commands
   console.log(chalk.bold('Step 6: Installing slash commands\n'));
 
@@ -1594,6 +1603,14 @@ export async function runInit(options = {}) {
         }
       }
 
+      // Create backup if overwriting existing file
+      if (existsSync(cmdPath) && createBackups) {
+        const backupPath = createBackup(cmdPath);
+        if (backupPath) {
+          backedUpFiles.push({ original: cmdPath, backup: backupPath });
+        }
+      }
+
       writeFileSync(cmdPath, content, 'utf8');
       installed.push(cmdName);
     } catch (error) {
@@ -1603,6 +1620,11 @@ export async function runInit(options = {}) {
 
   spinner.stop();
 
+  // Show backup summary if any files were backed up
+  if (backedUpFiles.length > 0) {
+    console.log(chalk.cyan(`\n  📁 Backed up ${backedUpFiles.length} file(s) to .claude/backups/`));
+  }
+
   // Step 7: Generate INDEX.md
   const indexPath = join(commandsDir, 'INDEX.md');
   const indexContent = generateIndexFile(installed, projectName);

package/src/commands/setup-wizard.js

@@ -9,8 +9,8 @@ import inquirer from 'inquirer';
 import chalk from 'chalk';
 import ora from 'ora';
 import boxen from 'boxen';
-import { existsSync, mkdirSync, writeFileSync, readFileSync } from 'fs';
-import { join } from 'path';
+import { existsSync, mkdirSync, writeFileSync, readFileSync, readdirSync, rmSync, renameSync, copyFileSync } from 'fs';
+import { join, basename } from 'path';
 import { runInit } from './init.js';
 import { detectTechStack } from './detect-tech-stack.js';
 import { runClaudeAudit, runEnhancement } from './claude-audit.js';
@@ -18,6 +18,272 @@ import { runSetup as runGitHubSetup } from './setup.js';
 import { runList } from './list.js';
 import { showProjectSettingsMenu } from '../cli/menu.js';
 
+/**
+ * Create backup of a file before overwriting
+ * @param {string} filePath - Path to file to backup
+ * @returns {string|null} - Path to backup file, or null if no backup needed
+ */
+export function createBackup(filePath) {
+  if (!existsSync(filePath)) return null;
+
+  const backupDir = join(process.cwd(), '.claude', 'backups');
+  if (!existsSync(backupDir)) {
+    mkdirSync(backupDir, { recursive: true });
+  }
+
+  const timestamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);
+  const fileName = basename(filePath);
+  const backupPath = join(backupDir, `${fileName}.${timestamp}.bak`);
+
+  copyFileSync(filePath, backupPath);
+  return backupPath;
+}
+
+/**
+ * Remove CCASP from a project
+ */
+async function runRemove() {
+  const claudeDir = join(process.cwd(), '.claude');
+
+  if (!existsSync(claudeDir)) {
+    console.log(chalk.yellow('\n⚠️  No .claude folder found in this project.\n'));
+    return false;
+  }
+
+  // Show what will be removed
+  console.log(chalk.bold('\n📁 CCASP files found in this project:\n'));
+
+  const itemsToRemove = [];
+
+  // Check for commands
+  const commandsDir = join(claudeDir, 'commands');
+  if (existsSync(commandsDir)) {
+    const commands = readdirSync(commandsDir).filter(f => f.endsWith('.md'));
+    if (commands.length > 0) {
+      console.log(`  ${chalk.cyan('commands/')} - ${commands.length} command(s)`);
+      itemsToRemove.push({ type: 'dir', path: commandsDir, label: 'commands/' });
+    }
+  }
+
+  // Check for agents
+  const agentsDir = join(claudeDir, 'agents');
+  if (existsSync(agentsDir)) {
+    const agents = readdirSync(agentsDir).filter(f => f.endsWith('.md'));
+    if (agents.length > 0) {
+      console.log(`  ${chalk.cyan('agents/')} - ${agents.length} agent(s)`);
+      itemsToRemove.push({ type: 'dir', path: agentsDir, label: 'agents/' });
+    }
+  }
+
+  // Check for skills
+  const skillsDir = join(claudeDir, 'skills');
+  if (existsSync(skillsDir)) {
+    const skills = readdirSync(skillsDir).filter(f => !f.startsWith('.'));
+    if (skills.length > 0) {
+      console.log(`  ${chalk.cyan('skills/')} - ${skills.length} skill(s)`);
+      itemsToRemove.push({ type: 'dir', path: skillsDir, label: 'skills/' });
+    }
+  }
+
+  // Check for hooks
+  const hooksDir = join(claudeDir, 'hooks');
+  if (existsSync(hooksDir)) {
+    const hooks = readdirSync(hooksDir).filter(f => f.endsWith('.js'));
+    if (hooks.length > 0) {
+      console.log(`  ${chalk.cyan('hooks/')} - ${hooks.length} hook(s)`);
+      itemsToRemove.push({ type: 'dir', path: hooksDir, label: 'hooks/' });
+    }
+  }
+
+  // Check for docs
+  const docsDir = join(claudeDir, 'docs');
+  if (existsSync(docsDir)) {
+    console.log(`  ${chalk.cyan('docs/')} - documentation`);
+    itemsToRemove.push({ type: 'dir', path: docsDir, label: 'docs/' });
+  }
+
+  // Check for config files
+  const configFiles = ['settings.json', 'settings.local.json', 'tech-stack.json'];
+  for (const file of configFiles) {
+    const filePath = join(claudeDir, file);
+    if (existsSync(filePath)) {
+      console.log(`  ${chalk.cyan(file)}`);
+      itemsToRemove.push({ type: 'file', path: filePath, label: file });
+    }
+  }
+
+  if (itemsToRemove.length === 0) {
+    console.log(chalk.yellow('  No CCASP items found.\n'));
+    return false;
+  }
+
+  console.log('');
+
+  // Removal options
+  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',
+        },
+      ],
+    },
+  ]);
+
+  if (removeAction === 'cancel') {
+    console.log(chalk.dim('\nCancelled. No changes made.\n'));
+    return false;
+  }
+
+  if (removeAction === 'backup' || removeAction === 'all') {
+    // Confirm dangerous action
+    const { confirmRemove } = await inquirer.prompt([
+      {
+        type: 'confirm',
+        name: 'confirmRemove',
+        message: chalk.red(`Are you sure you want to ${removeAction === 'all' ? 'DELETE' : 'backup and delete'} all CCASP files?`),
+        default: false,
+      },
+    ]);
+
+    if (!confirmRemove) {
+      console.log(chalk.dim('\nCancelled. No changes made.\n'));
+      return false;
+    }
+  }
+
+  const spinner = ora('Processing...').start();
+
+  try {
+    if (removeAction === 'backup') {
+      // Create backup first
+      const backupDir = join(process.cwd(), '.claude-backup', new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19));
+      mkdirSync(backupDir, { recursive: true });
+
+      // Copy entire .claude folder to backup
+      copyDirRecursive(claudeDir, backupDir);
+      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');
+
+      console.log(
+        boxen(
+          chalk.green('✅ CCASP removed with backup\n\n') +
+            `Backup location:\n${chalk.cyan(backupDir)}\n\n` +
+            chalk.dim('To restore: copy backup contents to .claude/'),
+          {
+            padding: 1,
+            borderStyle: 'round',
+            borderColor: 'green',
+          }
+        )
+      );
+    } else if (removeAction === 'all') {
+      // Remove without backup
+      rmSync(claudeDir, { recursive: true, force: true });
+      spinner.succeed('.claude folder removed');
+
+      console.log(
+        boxen(
+          chalk.green('✅ CCASP removed\n\n') +
+            chalk.dim('Run ') + chalk.cyan('ccasp wizard') + chalk.dim(' to set up again.'),
+          {
+            padding: 1,
+            borderStyle: 'round',
+            borderColor: 'green',
+          }
+        )
+      );
+    } else if (removeAction === 'selective') {
+      spinner.stop();
+
+      // Let user select what to remove
+      const { itemsToDelete } = await inquirer.prompt([
+        {
+          type: 'checkbox',
+          name: 'itemsToDelete',
+          message: 'Select items to remove:',
+          choices: itemsToRemove.map(item => ({
+            name: item.label,
+            value: item,
+            checked: false,
+          })),
+        },
+      ]);
+
+      if (itemsToDelete.length === 0) {
+        console.log(chalk.dim('\nNo items selected. No changes made.\n'));
+        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 });
+
+      for (const item of itemsToDelete) {
+        if (item.type === 'dir') {
+          copyDirRecursive(item.path, join(backupDir, basename(item.path)));
+          rmSync(item.path, { recursive: true, force: true });
+        } else {
+          copyFileSync(item.path, join(backupDir, basename(item.path)));
+          rmSync(item.path, { force: true });
+        }
+        console.log(`  ${chalk.red('✗')} Removed ${item.label}`);
+      }
+
+      console.log(chalk.dim(`\nBackups saved to: ${backupDir}\n`));
+    }
+
+    return true;
+  } catch (error) {
+    spinner.fail('Removal failed');
+    console.error(chalk.red(error.message));
+    return false;
+  }
+}
+
+/**
+ * Recursively copy a directory
+ */
+function copyDirRecursive(src, dest) {
+  mkdirSync(dest, { recursive: true });
+  const entries = readdirSync(src, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const srcPath = join(src, entry.name);
+    const destPath = join(dest, entry.name);
+
+    if (entry.isDirectory()) {
+      copyDirRecursive(srcPath, destPath);
+    } else {
+      copyFileSync(srcPath, destPath);
+    }
+  }
+}
+
 /**
  * Display setup header
  */
@@ -79,6 +345,11 @@ const SETUP_OPTIONS = [
     value: 'settings',
     short: 'Settings',
   },
+  {
+    name: `${chalk.yellow('9.')} Remove CCASP ${chalk.dim('- Uninstall from this project')}`,
+    value: 'remove',
+    short: 'Remove',
+  },
   {
     name: `${chalk.yellow('0.')} Exit`,
     value: 'exit',
@@ -435,6 +706,13 @@ export async function runSetupWizard(options = {}) {
         }
         break;
 
+      case 'remove':
+        const removed = await runRemove();
+        if (removed) {
+          running = false; // Exit wizard after removal
+        }
+        break;
+
       case 'exit':
         running = false;
         console.log(chalk.dim('\nRun `ccasp wizard` anytime to return.\n'));