@paulduvall/claude-dev-toolkit 0.0.1-alpha.6 → 0.0.1-alpha.8

package/README.md

@@ -41,7 +41,7 @@ npm install -g @paulduvall/claude-dev-toolkit
 ```bash
 # Install specific command sets
 claude-commands install --active        # Install 13 production commands
-claude-commands install --experimental  # Install 45 experimental commands  
+claude-commands install --experiments  # Install 45 experimental commands  
 claude-commands install --all           # Install all 58 commands
 ```
 
@@ -89,7 +89,7 @@ Advanced commands for specialized workflows:
 claude-commands list                    # List all available commands
 claude-commands status                  # Show installation status
 claude-commands install --active       # Install production commands
-claude-commands install --experimental # Install experimental commands
+claude-commands install --experiments # Install experimental commands
 claude-commands install --all          # Install all commands
 
 # Configuration Management
@@ -174,8 +174,8 @@ npm run lint             # Code linting
 - **Configuration Tests**: Template and setup validation
 
 ### Architecture
-- **Symlink Consolidation**: Single source of truth with root directory
-- **JavaScript-Based**: Migrated from Python for better Node.js integration
+- **Self-Contained Package**: No dependencies on repository cloning
+- **JavaScript-Based**: Native Node.js integration with comprehensive testing
 - **Modular Design**: Separate installer, config, and validation modules
 - **Cross-Platform**: Works on macOS, Linux, and Windows
 
@@ -203,7 +203,7 @@ claude-commands install --active       # Reinstall commands
 chmod 755 ~/.claude/commands/*.md      # Fix permissions
 
 # Missing experimental commands?
-claude-commands install --experimental # Install experimental set
+claude-commands install --experiments # Install experimental set
 
 # Test failures?
 npm test                               # Run full test suite
@@ -212,13 +212,13 @@ npm run validate                       # Validate package
 
 ### Validation Commands
 ```bash
-# Repository validation (from main repo)
-./validate-commands.sh                 # JavaScript-based validation
-./verify-setup.sh                     # Complete setup verification
-
 # Package validation
 npm run validate                       # Package structure validation
 npm test                              # Comprehensive test suite
+
+# CLI validation
+claude-commands verify                 # Complete setup verification
+claude-commands list                   # Check installed commands
 ```
 
 ## 📚 Documentation
@@ -252,8 +252,8 @@ npm test
 ```
 
 ### Adding Commands
-1. Create command files in root `slash-commands/active/` or `slash-commands/experiments/`
-2. Commands automatically sync to NPM package via symlinks
+1. Create command files in repository `slash-commands/active/` or `slash-commands/experiments/`
+2. Commands are included in NPM package through build process
 3. Validate with `npm run test:commands`
 4. Follow existing patterns and security guidelines
 
@@ -264,7 +264,7 @@ npm test
 
 ## 🔄 Recent Updates
 
-### Version 0.0.1-alpha.2
+### Version 0.0.1-alpha.7
 - ✅ **NPM Scoped Package**: Published as `@paulduvall/claude-dev-toolkit`
 - ✅ **Configuration Command**: Built-in `config` command for template management
 - ✅ **Workflow Reporting**: Comprehensive GitHub Actions reporting

package/bin/claude-commands

@@ -20,64 +20,53 @@ program
     .command('list')
     .description('List all available commands')
     .option('-a, --active', 'Show only active commands')
-    .option('-e, --experimental', 'Show only experimental commands')
+    .option('-e, --experiments', 'Show only experimental commands')
     .action((options) => {
         const claudeDir = path.join(os.homedir(), '.claude', 'commands');
-        const activeDir = path.join(claudeDir, 'active');
-        const experimentalDir = path.join(claudeDir, 'experiments');
         
         console.log('📦 Claude Custom Commands\n');
         
-        if (!options.experimental) {
-            console.log('🎯 Active Commands:');
-            if (fs.existsSync(activeDir)) {
-                const activeCommands = fs.readdirSync(activeDir)
-                    .filter(f => f.endsWith('.md'))
-                    .map(f => f.replace('.md', ''))
-                    .sort();
-                
-                if (activeCommands.length > 0) {
-                    activeCommands.forEach(cmd => console.log(`  /${cmd}`));
-                } else {
-                    console.log('  No active commands found');
-                }
-            } else {
-                console.log('  Commands directory not found');
-            }
-            console.log('');
-        }
-        
-        if (!options.active) {
-            console.log('🧪 Experimental Commands:');
-            if (fs.existsSync(experimentalDir)) {
-                const expCommands = fs.readdirSync(experimentalDir)
-                    .filter(f => f.endsWith('.md'))
-                    .map(f => f.replace('.md', ''))
-                    .sort();
-                
-                if (expCommands.length > 0) {
-                    expCommands.forEach(cmd => console.log(`  /${cmd}`));
-                } else {
-                    console.log('  No experimental commands found');
-                }
+        if (fs.existsSync(claudeDir)) {
+            const allCommands = fs.readdirSync(claudeDir)
+                .filter(f => f.endsWith('.md'))
+                .map(f => f.replace('.md', ''))
+                .sort();
+            
+            if (allCommands.length > 0) {
+                console.log('🚀 Available Commands:');
+                allCommands.forEach(cmd => console.log(`  /${cmd}`));
+                console.log(`\n📊 Total: ${allCommands.length} commands`);
             } else {
-                console.log('  Commands directory not found');
+                console.log('  No commands found');
             }
-            console.log('');
+        } else {
+            console.log('  Commands directory not found');
         }
         
-        console.log('💡 Usage: Try /xhelp in Claude Code to see all commands');
+        console.log('\n💡 Usage: Try /xhelp in Claude Code to see all commands');
     });
 
 program
     .command('install')
-    .description('Install command sets')
-    .option('--active', 'Install active commands only')
-    .option('--experimental', 'Install experimental commands')
-    .option('--all', 'Install all commands')
-    .action((options) => {
+    .description('Install command sets to ~/.claude/commands/')
+    .option('--active', 'Install production-ready commands (default)')
+    .option('--experiments', 'Install experimental commands only')
+    .option('--all', 'Install both active and experimental')
+    .option('--include <pattern>', 'Include specific commands matching pattern')
+    .option('--exclude <pattern>', 'Exclude commands matching pattern')
+    .option('--dry-run', 'Show what would be installed without making changes')
+    .option('--backup', 'Create backup before installation')
+    .action(async (options) => {
         const installer = require('../lib/installer');
-        installer.install(options);
+        try {
+            const result = await installer.install(options);
+            if (!result.success && !result.dryRun) {
+                process.exit(1);
+            }
+        } catch (error) {
+            console.error(`Installation failed: ${error.message}`);
+            process.exit(1);
+        }
     });
 
 program
@@ -85,33 +74,22 @@ program
     .description('Show installation status')
     .action(() => {
         const claudeDir = path.join(os.homedir(), '.claude', 'commands');
-        const activeDir = path.join(claudeDir, 'active');
-        const experimentalDir = path.join(claudeDir, 'experiments');
         
         console.log('📊 Claude Dev Toolkit Status\n');
         
         // Check Claude directory
-        console.log('📁 Installation Paths:');
-        console.log(`   Claude directory: ${fs.existsSync(claudeDir) ? '✅' : '❌'} ${claudeDir}`);
-        console.log(`   Active commands:  ${fs.existsSync(activeDir) ? '✅' : '❌'} ${activeDir}`);
-        console.log(`   Experimental:     ${fs.existsSync(experimentalDir) ? '✅' : '❌'} ${experimentalDir}\n`);
+        console.log('📁 Installation Path:');
+        console.log(`   Commands directory: ${fs.existsSync(claudeDir) ? '✅' : '❌'} ${claudeDir}\n`);
         
         // Count commands
-        let activeCount = 0;
-        let expCount = 0;
-        
-        if (fs.existsSync(activeDir)) {
-            activeCount = fs.readdirSync(activeDir).filter(f => f.endsWith('.md')).length;
-        }
+        let totalCount = 0;
         
-        if (fs.existsSync(experimentalDir)) {
-            expCount = fs.readdirSync(experimentalDir).filter(f => f.endsWith('.md')).length;
+        if (fs.existsSync(claudeDir)) {
+            totalCount = fs.readdirSync(claudeDir).filter(f => f.endsWith('.md')).length;
         }
         
         console.log('📦 Command Inventory:');
-        console.log(`   Active commands:      ${activeCount}`);
-        console.log(`   Experimental commands: ${expCount}`);
-        console.log(`   Total commands:       ${activeCount + expCount}\n`);
+        console.log(`   Total commands: ${totalCount}\n`);
         
         // Package info
         console.log('📋 Package Information:');
@@ -119,13 +97,13 @@ program
         console.log(`   CLI Location: ${process.argv[1]}\n`);
         
         // Quick health check
-        const isHealthy = fs.existsSync(claudeDir) && (activeCount > 0 || expCount > 0);
+        const isHealthy = fs.existsSync(claudeDir) && totalCount > 0;
         console.log(`🔍 Overall Status: ${isHealthy ? '✅ Healthy' : '⚠️  Issues detected'}`);
         
         if (!isHealthy) {
             console.log('\n💡 Troubleshooting:');
-            console.log('   • Try: npm install -g claude-dev-toolkit');
-            console.log('   • Or reinstall to refresh commands');
+            console.log('   • Try: npm install -g @paulduvall/claude-dev-toolkit');
+            console.log('   • Or reinstall: claude-commands install --all');
         }
     });
 
@@ -149,4 +127,147 @@ program
         config.handleCommand(options);
     });
 
+program
+    .command('configure')
+    .description('Configure Claude Code settings (replaces configure-claude-code.sh)')
+    .option('--template <name>', 'Apply named template')
+    .option('--interactive', 'Launch interactive configuration wizard')
+    .option('--validate', 'Validate current configuration')
+    .option('--reset', 'Reset to default configuration')
+    .option('--backup', 'Create backup before changes (default: true)')
+    .option('--no-backup', 'Skip backup creation')
+    .action(async (options) => {
+        const ConfigureCommand = require('../lib/configure-command');
+        const configureCmd = new ConfigureCommand();
+        try {
+            const result = await configureCmd.execute(options);
+            if (!result.success) {
+                process.exit(1);
+            }
+        } catch (error) {
+            console.error(`Configuration failed: ${error.message}`);
+            process.exit(1);
+        }
+    });
+
+program
+    .command('setup')
+    .description('Setup the Claude Dev Toolkit with custom commands and configuration')
+    .option('--type <template>', 'Configuration template to apply (basic, comprehensive, security-focused)')
+    .option('--commands <set>', 'Command set to install (active, experiments, all, none)')
+    .option('--skip-configure', 'Skip configuration step')
+    .option('--skip-hooks', 'Skip hooks installation')
+    .option('--force', 'Overwrite existing installation')
+    .option('--dry-run', 'Preview actions without executing')
+    .action(async (options) => {
+        const SetupCommand = require('../lib/setup-command');
+        const setupCmd = new SetupCommand();
+        try {
+            const result = await setupCmd.execute(options);
+            if (!result.success && !result.dryRun) {
+                process.exit(1);
+            }
+        } catch (error) {
+            console.error(`Setup failed: ${error.message}`);
+            process.exit(1);
+        }
+    });
+
+program
+    .command('verify')
+    .description('Verify the Claude Dev Toolkit installation status and health')
+    .option('--verbose', 'Show detailed verification information')
+    .option('--fix', 'Attempt to fix detected issues automatically')
+    .action(async (options) => {
+        const VerifyCommand = require('../lib/verify-command');
+        const verifyCmd = new VerifyCommand();
+        try {
+            const result = await verifyCmd.execute(options);
+            // Set exit code based on health status
+            if (result.overall === 'critical') {
+                process.exit(2);
+            } else if (result.overall === 'warning') {
+                process.exit(1);
+            }
+            // Exit 0 for healthy
+        } catch (error) {
+            console.error(`Verification failed: ${error.message}`);
+            process.exit(2);
+        }
+    });
+
+program
+    .command('backup [name]')
+    .description('Create named backup of Claude Code configuration')
+    .action(async (name) => {
+        const BackupRestoreCommand = require('../lib/backup-restore-command');
+        const backupCmd = new BackupRestoreCommand();
+        try {
+            const result = await backupCmd.backup(name);
+            if (!result.success) {
+                process.exit(1);
+            }
+        } catch (error) {
+            console.error(`Backup failed: ${error.message}`);
+            process.exit(1);
+        }
+    });
+
+program
+    .command('restore <name>')
+    .description('Restore from a named backup')
+    .action(async (name) => {
+        const BackupRestoreCommand = require('../lib/backup-restore-command');
+        const restoreCmd = new BackupRestoreCommand();
+        try {
+            const result = await restoreCmd.restore(name);
+            if (!result.success) {
+                process.exit(1);
+            }
+        } catch (error) {
+            console.error(`Restore failed: ${error.message}`);
+            process.exit(1);
+        }
+    });
+
+program
+    .command('update')
+    .description('Check for package updates')
+    .action(async () => {
+        const { version } = require('../package.json');
+        console.log('🔍 Checking for updates...\n');
+        console.log(`Current version: ${version}`);
+        
+        try {
+            const { execSync } = require('child_process');
+            const output = execSync('npm view @paulduvall/claude-dev-toolkit version', {
+                encoding: 'utf8',
+                stdio: 'pipe'
+            }).trim();
+            
+            console.log(`Latest version: ${output}`);
+            
+            if (output !== version) {
+                console.log('\n🆕 Update available!');
+                console.log('\nTo update, run:');
+                console.log('   npm update -g @paulduvall/claude-dev-toolkit');
+                
+                // Check for breaking changes in major version
+                const currentMajor = parseInt(version.split('.')[0]);
+                const latestMajor = parseInt(output.split('.')[0]);
+                
+                if (latestMajor > currentMajor) {
+                    console.log('\n⚠️  Major version update - may contain breaking changes');
+                    console.log('   Review release notes before updating');
+                }
+            } else {
+                console.log('\n✅ You are using the latest version');
+            }
+        } catch (error) {
+            console.error('❌ Could not check for updates');
+            console.log('   Please check your internet connection');
+            process.exit(1);
+        }
+    });
+
 program.parse(process.argv);

package/lib/backup-restore-command.js

@@ -0,0 +1,140 @@
+/**
+ * Backup and Restore Commands Implementation - Refactored
+ * Orchestrator for backup and restore operations using focused services
+ */
+
+const BackupService = require('./services/backup-service');
+const RestoreService = require('./services/restore-service');
+const BackupListService = require('./services/backup-list-service');
+const BaseCommand = require('./base/base-command');
+const FileSystemUtils = require('./utils/file-system-utils');
+const { execSync } = require('child_process');
+
+class BackupRestoreCommand extends BaseCommand {
+    constructor(config = null) {
+        super(config);
+        this.backupService = new BackupService(this.config);
+        this.restoreService = new RestoreService(this.config);
+        this.listService = new BackupListService(this.config);
+    }
+
+    /**
+     * Create a backup of the entire .claude directory
+     */
+    async backup(name = null) {
+        this.logger.step('Creating backup of Claude Code configuration', { backupName: name });
+
+        try {
+            const result = await this.backupService.create(name);
+            
+            // Try to compress the backup
+            const compressed = await this.compressBackup(result.path);
+            
+            this.logger.complete(`Backup '${result.name}' created successfully`, {
+                files: result.totalFiles,
+                size: FileSystemUtils.formatSize(result.totalSize),
+                compressed: !!compressed
+            });
+            
+            if (compressed) {
+                this.logger.info(`Backup compressed and stored at: ${compressed.path}`, { 
+                    compressionRatio: compressed.size / result.totalSize 
+                });
+            } else {
+                this.logger.info(`Backup stored at: ${result.path}`);
+            }
+            
+            return {
+                success: true,
+                name: result.name,
+                path: compressed ? compressed.path : result.path,
+                metadata: result.metadata
+            };
+
+        } catch (error) {
+            return this.handleError(error);
+        }
+    }
+
+    /**
+     * Try to compress a backup using tar
+     */
+    async compressBackup(backupPath) {
+        try {
+            const backupName = require('path').basename(backupPath);
+            const tarPath = `${backupPath}.tar.gz`;
+            
+            execSync(`tar -czf "${tarPath}" -C "${this.config.backupsDir}" "${backupName}"`, {
+                encoding: 'utf8',
+                stdio: 'pipe'
+            });
+            
+            // Remove uncompressed backup
+            FileSystemUtils.remove(backupPath);
+            
+            const compressedSize = FileSystemUtils.getStats(tarPath).size;
+            return { 
+                path: tarPath, 
+                size: compressedSize 
+            };
+        } catch (error) {
+            // Compression failed, keep uncompressed backup
+            return null;
+        }
+    }
+
+    /**
+     * Restore from a backup
+     */
+    async restore(backupName) {
+        this.logger.step(`Restoring from backup: ${backupName}`, { backupName });
+
+        try {
+            // Create undo backup first
+            this.logger.info('Creating undo backup for safety');
+            const undoBackup = await this.backup('undo-before-restore');
+            
+            if (!undoBackup.success) {
+                this.logger.warn('Could not create undo backup, continuing anyway', { 
+                    risk: 'restore cannot be undone' 
+                });
+            }
+
+            // Perform restore using service
+            const result = await this.restoreService.restore(backupName);
+
+            this.logger.complete(`Restore completed successfully`, {
+                restoredCount: result.restoredCount,
+                hasUndo: undoBackup.success
+            });
+            
+            if (undoBackup.success) {
+                this.logger.info(`To undo this restore, run: claude-commands restore ${undoBackup.name}`, {
+                    undoCommand: `claude-commands restore ${undoBackup.name}`
+                });
+            }
+
+            return {
+                success: true,
+                restoredCount: result.restoredCount,
+                undoBackup: undoBackup.success ? undoBackup.name : null
+            };
+
+        } catch (error) {
+            return this.handleError(error);
+        }
+    }
+
+    /**
+     * List available backups
+     */
+    async listBackups() {
+        try {
+            return await this.listService.display();
+        } catch (error) {
+            return this.handleError(error);
+        }
+    }
+}
+
+module.exports = BackupRestoreCommand;