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

package/lib/setup-wizard.js

@@ -2,354 +2,247 @@
 
 /**
  * Interactive Setup Wizard for REQ-007
- * GREEN phase - Minimal implementation to pass tests
  */
 
 const fs = require('fs');
 const path = require('path');
 const readline = require('readline');
 
-// Import extracted classes for better separation of concerns
 const SetupWizardUI = require('./setup-wizard-ui');
 const InstallationConfiguration = require('./installation-configuration');
 const CommandSelector = require('./command-selector');
 
+function getDefaultConfig() {
+    return {
+        installationType: 'standard',
+        commandSets: ['development', 'planning'],
+        securityHooks: true,
+        selectedHooks: ['credential-protection'],
+        template: 'basic'
+    };
+}
+
+function buildConfigResult(success, configPath) {
+    return {
+        saved: success,
+        file: success ? configPath : null,
+        error: success ? null : 'Failed to save configuration'
+    };
+}
+
+function buildSecurityHooksList() {
+    return [
+        { id: 1, name: 'credential-protection', description: 'Prevents credential exposure in commits', file: 'prevent-credential-exposure.sh' },
+        { id: 2, name: 'file-logger', description: 'Logs file operations for audit trail', file: 'file-logger.sh' },
+        { id: 3, name: 'pre-commit-quality', description: 'Code quality checks before commits', file: 'pre-commit-quality.sh' },
+        { id: 4, name: 'pre-write-security', description: 'Security scan before file writes', file: 'pre-write-security.sh' },
+        { id: 5, name: 'pre-commit-test-runner', description: 'Auto-detects and runs project tests before commits', file: 'pre-commit-test-runner.sh' },
+        { id: 6, name: 'verify-before-edit', description: 'Warns about fabricated references in edits', file: 'verify-before-edit.sh' },
+        { id: 7, name: 'audit-bash-commands', description: 'Logs shell commands for security audit', file: 'audit-bash-commands.sh' },
+        { id: 8, name: 'log-all-operations', description: 'Audit trail for all tool usage', file: 'log-all-operations.sh' },
+        { id: 9, name: 'validate-changes', description: 'Post-edit validation of changes', file: 'validate-changes.sh' },
+        { id: 10, name: 'backup-before-edit', description: 'Preserves file state before modifications', file: 'backup-before-edit.sh' },
+        { id: 11, name: 'session-init', description: 'Validates environment at session start', file: 'session-init.sh' },
+        { id: 12, name: 'session-cleanup', description: 'End-of-session security cleanup', file: 'session-cleanup.sh' },
+        { id: 13, name: 'prompt-security-scan', description: 'Scans prompts for credential exposure risks', file: 'prompt-security-scan.sh' }
+    ];
+}
+
+function enhanceConfig(configData) {
+    return { timestamp: new Date().toISOString(), version: '1.0.0', ...configData };
+}
+
 class InteractiveSetupWizard {
     constructor(packageRoot) {
         this.packageRoot = packageRoot;
-        
-        // Import config module for template application
+
         const config = require('./config');
         this.applyConfigurationTemplate = config.applyConfigurationTemplate;
-        
-        // Import hook installer for security hooks
+
         const hookInstaller = require('./hook-installer');
         this.installSecurityHooks = hookInstaller.installSecurityHooks;
         this.getAvailableHooks = hookInstaller.getAvailableHooks;
-        
-        // Initialize extracted components
+
         this.ui = new SetupWizardUI();
         this.config = new InstallationConfiguration(packageRoot);
         this.commandSelector = new CommandSelector();
-        
-        // Legacy data for backward compatibility
-        this.securityHooks = [
-            {
-                id: 1,
-                name: 'credential-protection',
-                description: 'Prevents credential exposure in commits',
-                file: 'prevent-credential-exposure.sh'
-            },
-            {
-                id: 2,
-                name: 'file-logger',
-                description: 'Logs file operations for audit trail',
-                file: 'file-logger.sh'
-            }
-        ];
+        this.securityHooks = buildSecurityHooksList();
     }
-    
+
     validateEnvironment() {
         try {
-            // Check write permissions
             const testFile = path.join(this.packageRoot, '.test');
             fs.writeFileSync(testFile, 'test');
             fs.unlinkSync(testFile);
-            
-            return {
-                valid: true,
-                message: 'Environment validation passed'
-            };
+            return { valid: true, message: 'Environment validation passed' };
         } catch (error) {
-            return {
-                valid: false,
-                message: `Environment validation failed: ${error.message}`
-            };
+            return { valid: false, message: `Environment validation failed: ${error.message}` };
         }
     }
-    
+
     getInstallationTypes() {
         return this.config.getInstallationTypes();
     }
-    
+
     selectInstallationType(optionId) {
         const selected = this.config.getInstallationTypeById(optionId);
-        if (selected) {
-            return {
-                type: selected.name.toLowerCase().split(' ')[0],
-                description: selected.description,
-                commands: selected.commands
-            };
-        }
-        return null;
+        if (!selected) return null;
+        return { type: selected.name.toLowerCase().split(' ')[0], description: selected.description, commands: selected.commands };
     }
-    
+
     getCommandCategories() {
         return this.commandSelector.getCommandCategories();
     }
-    
+
     selectCommandSets(categories) {
         return this.commandSelector.selectCommandSets(categories);
     }
-    
+
     getSecurityHooks() {
         return this.securityHooks;
     }
-    
+
     selectSecurityHooks(hookIds) {
-        const selected = hookIds.map(id => 
-            this.securityHooks.find(h => h.id === id)
-        ).filter(Boolean);
-        
-        return {
-            enabled: selected.length > 0,
-            selected: selected.map(h => h.name)
-        };
+        const selected = hookIds.map(id => this.securityHooks.find(h => h.id === id)).filter(Boolean);
+        return { enabled: selected.length > 0, selected: selected.map(h => h.name) };
     }
-    
+
     getConfigurationTemplates() {
         return this.config.getConfigurationTemplates();
     }
-    
+
     selectConfigurationTemplate(templateName) {
-        const templates = this.config.getConfigurationTemplates();
-        const template = templates.find(t => t.name === templateName);
-        
-        if (template) {
-            return {
-                template: template.name,
-                file: template.filename,
-                description: template.description
-            };
-        }
-        return null;
+        const template = this.config.getConfigurationTemplates().find(t => t.name === templateName);
+        if (!template) return null;
+        return { template: template.name, file: template.filename, description: template.description };
     }
-    
+
     runNonInteractiveSetup() {
-        const defaultConfig = {
-            installationType: 'standard',
-            commandSets: ['development', 'planning'],
-            securityHooks: true,
-            selectedHooks: ['credential-protection'],
-            template: 'basic'
-        };
-        
-        this.saveConfiguration(defaultConfig);
-        
-        return {
-            completed: true,
-            configuration: defaultConfig
-        };
+        const cfg = getDefaultConfig();
+        this.saveConfiguration(cfg);
+        return { completed: true, configuration: cfg };
     }
-    
+
     async runNonInteractiveSetupAsync() {
-        const defaultConfig = {
-            installationType: 'standard',
-            commandSets: ['development', 'planning'],
-            securityHooks: true,
-            selectedHooks: ['credential-protection'],
-            template: 'basic'
-        };
-        
-        await this.saveConfigurationAsync(defaultConfig);
-        
-        return {
-            completed: true,
-            configuration: defaultConfig
-        };
+        const cfg = getDefaultConfig();
+        await this.saveConfigurationAsync(cfg);
+        return { completed: true, configuration: cfg };
     }
-    
+
     saveConfiguration(configData) {
-        const enhancedConfig = {
-            timestamp: new Date().toISOString(),
-            version: '1.0.0',
-            ...configData
-        };
-        
-        const success = this.config.saveConfiguration(enhancedConfig);
-        return {
-            saved: success,
-            file: success ? this.config.getConfigurationPath() : null,
-            error: success ? null : 'Failed to save configuration'
-        };
+        const success = this.config.saveConfiguration(enhanceConfig(configData));
+        return buildConfigResult(success, this.config.getConfigurationPath());
     }
-    
+
     async saveConfigurationAsync(configData) {
-        const enhancedConfig = {
-            timestamp: new Date().toISOString(),
-            version: '1.0.0',
-            ...configData
-        };
-        
-        const success = await this.config.saveConfigurationAsync(enhancedConfig);
-        return {
-            saved: success,
-            file: success ? this.config.getConfigurationPath() : null,
-            error: success ? null : 'Failed to save configuration'
-        };
+        const success = await this.config.saveConfigurationAsync(enhanceConfig(configData));
+        return buildConfigResult(success, this.config.getConfigurationPath());
     }
-    
+
     loadConfiguration() {
-        const configData = this.config.loadConfiguration();
-        if (configData) {
-            return {
-                found: true,
-                config: configData
-            };
-        }
-        return {
-            found: false
-        };
+        const data = this.config.loadConfiguration();
+        return data ? { found: true, config: data } : { found: false };
     }
-    
+
     async loadConfigurationAsync() {
-        const configData = await this.config.loadConfigurationAsync();
-        if (configData) {
-            return {
-                found: true,
-                config: configData
-            };
-        }
-        return {
-            found: false
-        };
+        const data = await this.config.loadConfigurationAsync();
+        return data ? { found: true, config: data } : { found: false };
     }
-    
+
     applyPreset(presetName) {
         return this.commandSelector.applyPreset(presetName);
     }
-    
+
+    async promptInstallationType(ask) {
+        console.log('\n📦 Installation Type:');
+        this.installationTypes.forEach(t => console.log(`${t.id}. ${t.name}\n   ${t.description}`));
+        const choice = await ask('\nSelect installation type (1-3): ');
+        return this.selectInstallationType(parseInt(choice));
+    }
+
+    async promptCommandSets(ask) {
+        console.log('\n🛠️  Command Sets:');
+        const cats = Object.keys(this.commandCategories);
+        cats.forEach((c, i) => console.log(`${i + 1}. ${c} (${this.commandCategories[c].length} commands)`));
+        const choice = await ask('\nSelect command sets (comma-separated numbers): ');
+        return choice.split(',').map(s => cats[parseInt(s.trim()) - 1]).filter(Boolean);
+    }
+
+    async promptSecurityHooks(ask, config) {
+        const enable = await ask('\n🔒 Enable security hooks? (y/n): ');
+        if (enable.toLowerCase() !== 'y') {
+            config.securityHooks = false;
+            config.selectedHooks = [];
+            return;
+        }
+        console.log('\nAvailable hooks:');
+        this.securityHooks.forEach(h => console.log(`${h.id}. ${h.name}\n   ${h.description}`));
+        const choice = await ask('\nSelect hooks (comma-separated numbers): ');
+        const ids = choice.split(',').map(h => parseInt(h.trim()));
+        const selected = this.selectSecurityHooks(ids);
+        config.securityHooks = selected.enabled;
+        config.selectedHooks = selected.selected;
+    }
+
+    async promptAndApplyTemplate(ask, config) {
+        console.log('\n⚙️  Configuration Templates:');
+        this.configurationTemplates.forEach(t => console.log(`${t.id}. ${t.name}\n   ${t.description}`));
+        const choice = await ask('\nSelect template (1-3): ');
+        const tpl = this.configurationTemplates.find(t => t.id === parseInt(choice));
+        if (!tpl) return;
+        config.template = tpl.name;
+        await this.saveConfigurationAsync(config);
+        const tplPath = path.join(this.packageRoot, 'templates', tpl.filename);
+        const settingsPath = path.join(require('os').homedir(), '.claude', 'settings.json');
+        console.log(`\n📋 Applying configuration template: ${tpl.name}`);
+        const applied = this.applyConfigurationTemplate(tplPath, settingsPath);
+        config.templateApplied = applied;
+        if (applied) {
+            config.settingsPath = settingsPath;
+            console.log(`✅ Template applied to: ${settingsPath}`);
+        } else {
+            console.log('⚠️  Template application failed, but setup will continue');
+        }
+    }
+
+    async collectSetupChoices(ask) {
+        const config = {};
+        const selectedType = await this.promptInstallationType(ask);
+        if (selectedType) config.installationType = selectedType.type;
+        config.commandSets = await this.promptCommandSets(ask);
+        await this.promptSecurityHooks(ask, config);
+        await this.promptAndApplyTemplate(ask, config);
+        return config;
+    }
+
     async runInteractiveSetup() {
-        const rl = readline.createInterface({
-            input: process.stdin,
-            output: process.stdout
-        });
-        
-        const question = (prompt) => new Promise((resolve) => {
-            rl.question(prompt, resolve);
-        });
-        
+        const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+        const ask = (prompt) => new Promise((resolve) => rl.question(prompt, resolve));
         console.log('\n🚀 Claude Dev Toolkit Interactive Setup Wizard');
-        console.log('=' .repeat(50));
-        
-        const config = {};
-        
+        console.log('='.repeat(50));
         try {
-            // Installation type
-            console.log('\n📦 Installation Type:');
-            this.installationTypes.forEach(type => {
-                console.log(`${type.id}. ${type.name}`);
-                console.log(`   ${type.description}`);
-            });
-            
-            const typeChoice = await question('\nSelect installation type (1-3): ');
-            const selectedType = this.selectInstallationType(parseInt(typeChoice));
-            if (selectedType) {
-                config.installationType = selectedType.type;
-            }
-            
-            // Command sets
-            console.log('\n🛠️  Command Sets:');
-            const categories = Object.keys(this.commandCategories);
-            categories.forEach((cat, i) => {
-                console.log(`${i + 1}. ${cat} (${this.commandCategories[cat].length} commands)`);
-            });
-            
-            const setChoice = await question('\nSelect command sets (comma-separated numbers): ');
-            const selectedIndices = setChoice.split(',').map(s => parseInt(s.trim()) - 1);
-            const selectedSets = selectedIndices.map(i => categories[i]).filter(Boolean);
-            config.commandSets = selectedSets;
-            
-            // Security hooks
-            const enableHooks = await question('\n🔒 Enable security hooks? (y/n): ');
-            if (enableHooks.toLowerCase() === 'y') {
-                console.log('\nAvailable hooks:');
-                this.securityHooks.forEach(hook => {
-                    console.log(`${hook.id}. ${hook.name}`);
-                    console.log(`   ${hook.description}`);
-                });
-                
-                const hookChoice = await question('\nSelect hooks (comma-separated numbers): ');
-                const hookIds = hookChoice.split(',').map(h => parseInt(h.trim()));
-                const selectedHooks = this.selectSecurityHooks(hookIds);
-                config.securityHooks = selectedHooks.enabled;
-                config.selectedHooks = selectedHooks.selected;
-            } else {
-                config.securityHooks = false;
-                config.selectedHooks = [];
-            }
-            
-            // Configuration template
-            console.log('\n⚙️  Configuration Templates:');
-            this.configurationTemplates.forEach(template => {
-                console.log(`${template.id}. ${template.name}`);
-                console.log(`   ${template.description}`);
-            });
-            
-            const templateChoice = await question('\nSelect template (1-3): ');
-            const templateId = parseInt(templateChoice);
-            const selectedTemplate = this.configurationTemplates.find(t => t.id === templateId);
-            if (selectedTemplate) {
-                config.template = selectedTemplate.name;
-            }
-            
-            // Save configuration
-            await this.saveConfigurationAsync(config);
-            
-            // Apply selected configuration template (REQ-009 integration)
-            if (selectedTemplate) {
-                const templatesDir = path.join(this.packageRoot, 'templates');
-                const templatePath = path.join(templatesDir, selectedTemplate.filename);
-                const settingsPath = path.join(require('os').homedir(), '.claude', 'settings.json');
-                
-                console.log(`\n📋 Applying configuration template: ${selectedTemplate.name}`);
-                const applied = this.applyConfigurationTemplate(templatePath, settingsPath);
-                if (applied) {
-                    console.log(`✅ Template applied to: ${settingsPath}`);
-                    config.templateApplied = true;
-                    config.settingsPath = settingsPath;
-                } else {
-                    console.log('⚠️  Template application failed, but setup will continue');
-                    config.templateApplied = false;
-                }
-            }
-            
+            const config = await this.collectSetupChoices(ask);
             console.log('\n✅ Setup completed successfully!');
-            console.log(`Configuration saved to: ${this.configFile}`);
-            
             rl.close();
-            
-            return {
-                completed: true,
-                configuration: config
-            };
-            
+            return { completed: true, configuration: config };
         } catch (error) {
             rl.close();
-            return {
-                completed: false,
-                error: error.message
-            };
+            return { completed: false, error: error.message };
         }
     }
 }
 
-// Support for PostInstaller integration
 class PostInstaller {
     constructor() {
         this.packageRoot = path.join(require('os').homedir(), '.claude');
     }
-    
+
     runSetupWizard(options = {}) {
-        if (options.skipSetup) {
-            return { skipped: true };
-        }
-        
+        if (options.skipSetup) return { skipped: true };
         const wizard = new InteractiveSetupWizard(this.packageRoot);
         return wizard.runNonInteractiveSetup();
     }
 }
 
-// Export both classes
 module.exports = InteractiveSetupWizard;
-module.exports.PostInstaller = PostInstaller;
+module.exports.PostInstaller = PostInstaller;

package/lib/uninstall-command.js

@@ -0,0 +1,100 @@
+/**
+ * Uninstall Command
+ *
+ * Removes all files installed by claude-dev-toolkit:
+ * - ~/.claude/commands/*.md (slash commands)
+ * - ~/.claude/hooks/*.sh (hook scripts)
+ * - ~/.claude/sub-agents/*.md (subagent definitions)
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const CLAUDE_DIR = path.join(os.homedir(), '.claude');
+
+const TARGETS = [
+    { dir: path.join(CLAUDE_DIR, 'commands'), pattern: /\.md$/, label: 'commands' },
+    { dir: path.join(CLAUDE_DIR, 'hooks'), pattern: /\.sh$/, label: 'hooks' },
+    { dir: path.join(CLAUDE_DIR, 'sub-agents'), pattern: /\.md$/, label: 'subagents' },
+];
+
+function listFiles(dir, pattern) {
+    if (!fs.existsSync(dir)) return [];
+    return fs.readdirSync(dir)
+        .filter(f => pattern.test(f))
+        .map(f => path.join(dir, f));
+}
+
+function removeFiles(files, dryRun) {
+    let removed = 0;
+    for (const file of files) {
+        if (dryRun) {
+            console.log(`  Would remove: ${file}`);
+        } else {
+            fs.unlinkSync(file);
+        }
+        removed++;
+    }
+    return removed;
+}
+
+function removeAllTargets(dryRun) {
+    const prefix = dryRun ? '[DRY RUN] ' : '';
+    let totalRemoved = 0;
+
+    for (const target of TARGETS) {
+        const files = listFiles(target.dir, target.pattern);
+        if (files.length === 0) continue;
+
+        console.log(`${prefix}Removing ${files.length} ${target.label}:`);
+        totalRemoved += removeFiles(files, dryRun);
+        console.log('');
+    }
+    return totalRemoved;
+}
+
+function execute(options = {}) {
+    const { dryRun, keepSettings } = options;
+    const prefix = dryRun ? '[DRY RUN] ' : '';
+
+    console.log(`${prefix}Uninstalling claude-dev-toolkit files...\n`);
+
+    const totalRemoved = removeAllTargets(dryRun);
+    if (!keepSettings) handleSettingsCleanup(dryRun, prefix);
+    printSummary(totalRemoved, dryRun);
+}
+
+function handleSettingsCleanup(dryRun, prefix) {
+    const settingsPath = path.join(CLAUDE_DIR, 'settings.json');
+    if (!fs.existsSync(settingsPath)) return;
+
+    console.log(`${prefix}Cleaning settings.json (removing sub_agents key)`);
+    if (dryRun) return;
+
+    try {
+        const raw = fs.readFileSync(settingsPath, 'utf8');
+        const settings = JSON.parse(raw);
+        delete settings.sub_agents;
+        fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
+    } catch (err) {
+        console.log(`  Warning: could not clean settings.json: ${err.message}`);
+    }
+}
+
+function printSummary(totalRemoved, dryRun) {
+    if (totalRemoved === 0) {
+        console.log('Nothing to remove. No installed files found.');
+        return;
+    }
+
+    const action = dryRun ? 'Would remove' : 'Removed';
+    console.log(`\n${action} ${totalRemoved} file(s).`);
+
+    if (!dryRun) {
+        console.log('\nTo fully uninstall the npm package:');
+        console.log('  npm uninstall -g @paulduvall/claude-dev-toolkit');
+    }
+}
+
+module.exports = { execute };