@paulduvall/claude-dev-toolkit 0.0.1-alpha.2 → 0.0.1-alpha.21

package/bin/claude-commands

@@ -19,65 +19,93 @@ program
 program
     .command('list')
     .description('List all available commands')
+    .addHelpText('after', `
+Examples:
+  $ claude-commands list              # List all installed commands
+  $ claude-commands list --active     # Show only production commands
+  $ claude-commands list --experiments # Show only experimental 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');
-        
+        const pkgDir = path.join(__dirname, '..', 'commands');
+
         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');
+
+        // Determine source: installed commands or package commands
+        const sourceDir = fs.existsSync(claudeDir) ? claudeDir : null;
+
+        if (sourceDir) {
+            let allCommands = fs.readdirSync(sourceDir)
+                .filter(f => f.endsWith('.md'))
+                .map(f => f.replace('.md', ''))
+                .sort();
+
+            // Apply --active/--experiments filters using package source dirs
+            if (options.active || options.experiments) {
+                const activeDir = path.join(pkgDir, 'active');
+                const expDir = path.join(pkgDir, 'experiments');
+                const activeSet = new Set();
+                const expSet = new Set();
+
+                if (fs.existsSync(activeDir)) {
+                    fs.readdirSync(activeDir)
+                        .filter(f => f.endsWith('.md'))
+                        .forEach(f => activeSet.add(f.replace('.md', '')));
                 }
-            } 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(expDir)) {
+                    fs.readdirSync(expDir)
+                        .filter(f => f.endsWith('.md'))
+                        .forEach(f => expSet.add(f.replace('.md', '')));
+                }
+
+                if (options.active) {
+                    allCommands = allCommands.filter(cmd => activeSet.has(cmd));
+                } else if (options.experiments) {
+                    allCommands = allCommands.filter(cmd => expSet.has(cmd));
                 }
+            }
+
+            if (allCommands.length > 0) {
+                const label = options.active ? 'Active' : options.experiments ? 'Experimental' : 'Available';
+                console.log(`🚀 ${label} 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 matching filter');
             }
-            console.log('');
+        } else {
+            console.log('  Commands directory not found');
+            console.log('  Run: claude-commands install');
         }
-        
-        console.log('💡 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/')
+    .addHelpText('after', `
+Examples:
+  $ claude-commands install            # Install active commands (default)
+  $ claude-commands install --all      # Install all commands
+  $ claude-commands install --dry-run  # Preview without changes`)
+    .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 +113,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;
+        let totalCount = 0;
         
-        if (fs.existsSync(activeDir)) {
-            activeCount = fs.readdirSync(activeDir).filter(f => f.endsWith('.md')).length;
-        }
-        
-        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 +136,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 +166,229 @@ 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')
+    .addHelpText('after', `
+Examples:
+  $ claude-commands setup                            # Interactive setup
+  $ claude-commands setup --type basic --commands all # Basic config, all commands
+  $ claude-commands setup --dry-run                   # Preview setup actions`)
+    .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('oidc')
+    .description(`Configure GitHub Actions OIDC (OpenID Connect) integration with AWS
+
+    🎯 WHAT IT DOES:
+    • Creates GitHub OIDC identity provider in AWS
+    • Sets up IAM role with trust policy for GitHub Actions
+    • Configures repository variables for secure AWS access
+    • Enables passwordless authentication from GitHub to AWS
+
+    📋 PREREQUISITES (REQUIRED):
+    • AWS CLI installed and configured (aws configure)
+    • GitHub CLI authenticated (gh auth login) 
+    • Git repository with GitHub remote origin
+    • AWS account with IAM permissions
+
+    ⚙️  WHAT IT CREATES:
+    • AWS OIDC Identity Provider for GitHub
+    • IAM Role for GitHub Actions (with trust policy)
+    • IAM policies for AWS resource access
+    • GitHub repository variables (AWS_DEPLOYMENT_ROLE, AWS_REGION)
+
+    🚀 BASIC USAGE:
+    • claude-commands oidc                    # Auto-detect settings
+    • claude-commands oidc --dry-run          # Preview without changes
+    • claude-commands oidc --region us-west-2 # Specify AWS region`)
+    .option('--region <region>', 'AWS region for OIDC setup', 'us-east-1')
+    .option('--role-name <name>', 'IAM role name for GitHub Actions', 'GitHubActionsRole')
+    .option('--repository-path <path>', 'Path to repository for OIDC setup (auto-detected)', process.cwd())
+    .option('--dry-run', 'Preview actions without making changes (SAFE to run)')
+    .option('--verbose', 'Show detailed output during execution')
+    .action(async (options) => {
+        const OidcCommand = require('../lib/oidc-command');
+        const oidcCmd = new OidcCommand();
+        try {
+            const result = await oidcCmd.execute(options);
+            if (result.success) {
+                if (result.message) {
+                    console.log(result.message);
+                }
+                if (options.verbose && result.duration) {
+                    console.log(`✅ Completed in ${result.duration}ms`);
+                }
+            } else {
+                console.error(`❌ OIDC setup failed: ${result.error || 'Unknown error'}`);
+                if (result.enhancedError && result.enhancedError.suggestions) {
+                    result.enhancedError.suggestions.forEach(suggestion => {
+                        console.log(suggestion);
+                    });
+                }
+                process.exit(1);
+            }
+        } catch (error) {
+            console.error(`❌ OIDC setup 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
+    .command('uninstall')
+    .description('Remove all installed commands, hooks, and subagents')
+    .addHelpText('after', `
+Examples:
+  $ claude-commands uninstall           # Remove all installed files
+  $ claude-commands uninstall --dry-run # Preview what would be removed`)
+    .option('--dry-run', 'Preview what would be removed without deleting')
+    .option('--keep-settings', 'Keep settings.json intact')
+    .action((options) => {
+        const uninstaller = require('../lib/uninstall-command');
+        try {
+            uninstaller.execute(options);
+        } catch (error) {
+            console.error(`Uninstall failed: ${error.message}`);
+            process.exit(1);
+        }
+    });
+
 program.parse(process.argv);