@paulduvall/claude-dev-toolkit 0.0.1-alpha.1

package/lib/setup-wizard-ui.js

@@ -0,0 +1,245 @@
+const readline = require('readline');
+
+/**
+ * Handles user interface interactions for the setup wizard
+ * Extracted from InteractiveSetupWizard for better separation of concerns
+ */
+class SetupWizardUI {
+    constructor() {
+        this.rl = null;
+    }
+
+    /**
+     * Create readline interface
+     */
+    createInterface() {
+        this.rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout
+        });
+    }
+
+    /**
+     * Close readline interface
+     */
+    closeInterface() {
+        if (this.rl) {
+            this.rl.close();
+            this.rl = null;
+        }
+    }
+
+    /**
+     * Display welcome message
+     */
+    showWelcome() {
+        console.log('\n🚀 Claude Code Custom Commands Setup Wizard');
+        console.log('='.repeat(50));
+        console.log('Welcome to the interactive setup wizard!');
+        console.log('This will guide you through configuring your Claude Code toolkit.\n');
+    }
+
+    /**
+     * Display installation types menu
+     * @param {Array} installationTypes - Available installation types
+     */
+    showInstallationTypes(installationTypes) {
+        console.log('📦 Installation Types:');
+        console.log('-'.repeat(25));
+        installationTypes.forEach(type => {
+            console.log(`${type.id}. ${type.name}`);
+            console.log(`   ${type.description}`);
+            console.log('');
+        });
+    }
+
+    /**
+     * Display command categories
+     * @param {Object} commandCategories - Available command categories
+     */
+    showCommandCategories(commandCategories) {
+        console.log('\n📋 Available Command Categories:');
+        console.log('-'.repeat(35));
+        Object.entries(commandCategories).forEach(([category, commands], index) => {
+            console.log(`${index + 1}. ${category.charAt(0).toUpperCase() + category.slice(1)} (${commands.length} commands)`);
+            console.log(`   Commands: ${commands.join(', ')}`);
+        });
+    }
+
+    /**
+     * Display available hooks
+     * @param {Array} availableHooks - Available security hooks
+     */
+    showAvailableHooks(availableHooks) {
+        console.log('\n🔒 Available Security Hooks:');
+        console.log('-'.repeat(30));
+        availableHooks.forEach((hook, index) => {
+            console.log(`${index + 1}. ${hook.name}`);
+            if (hook.description) {
+                console.log(`   ${hook.description}`);
+            }
+        });
+    }
+
+    /**
+     * Display configuration templates
+     * @param {Array} templates - Available configuration templates
+     */
+    showConfigurationTemplates(templates) {
+        console.log('\n⚙️ Configuration Templates:');
+        console.log('-'.repeat(28));
+        templates.forEach((template, index) => {
+            console.log(`${index + 1}. ${template.name}`);
+            console.log(`   ${template.description}`);
+        });
+    }
+
+    /**
+     * Prompt user for input
+     * @param {string} question - Question to ask
+     * @returns {Promise<string>} User's response
+     */
+    prompt(question) {
+        return new Promise((resolve) => {
+            this.rl.question(question, (answer) => {
+                resolve(answer.trim());
+            });
+        });
+    }
+
+    /**
+     * Prompt for yes/no confirmation
+     * @param {string} question - Question to ask
+     * @param {boolean} defaultValue - Default value if user just presses enter
+     * @returns {Promise<boolean>} User's confirmation
+     */
+    async confirmPrompt(question, defaultValue = false) {
+        const defaultText = defaultValue ? '[Y/n]' : '[y/N]';
+        const answer = await this.prompt(`${question} ${defaultText}: `);
+        
+        if (answer === '') {
+            return defaultValue;
+        }
+        
+        return answer.toLowerCase().startsWith('y');
+    }
+
+    /**
+     * Prompt for numeric choice
+     * @param {string} question - Question to ask
+     * @param {number} min - Minimum valid number
+     * @param {number} max - Maximum valid number
+     * @returns {Promise<number>} User's choice
+     */
+    async numericPrompt(question, min = 1, max = 10) {
+        while (true) {
+            const answer = await this.prompt(question);
+            const num = parseInt(answer);
+            
+            if (!isNaN(num) && num >= min && num <= max) {
+                return num;
+            }
+            
+            console.log(`❌ Please enter a number between ${min} and ${max}`);
+        }
+    }
+
+    /**
+     * Prompt for multiple choices
+     * @param {string} question - Question to ask
+     * @param {Array} choices - Available choices
+     * @returns {Promise<Array<number>>} User's choices
+     */
+    async multipleChoicePrompt(question, choices) {
+        const answer = await this.prompt(`${question} (comma-separated numbers, or 'all'): `);
+        
+        if (answer.toLowerCase() === 'all') {
+            return choices.map((_, index) => index + 1);
+        }
+        
+        const selected = answer.split(',')
+            .map(s => parseInt(s.trim()))
+            .filter(n => !isNaN(n) && n >= 1 && n <= choices.length);
+            
+        return selected.length > 0 ? selected : [1]; // Default to first choice
+    }
+
+    /**
+     * Display setup summary
+     * @param {Object} config - Setup configuration
+     */
+    showSetupSummary(config) {
+        console.log('\n📋 Setup Summary:');
+        console.log('='.repeat(20));
+        console.log(`Installation Type: ${config.installationType}`);
+        console.log(`Commands: ${config.selectedCommands.length} selected`);
+        console.log(`Security Hooks: ${config.securityHooks ? 'Yes' : 'No'}`);
+        console.log(`Configuration Template: ${config.configTemplate || 'None'}`);
+        console.log('');
+    }
+
+    /**
+     * Display progress indicator
+     * @param {string} step - Current step
+     * @param {number} current - Current step number
+     * @param {number} total - Total steps
+     */
+    showProgress(step, current, total) {
+        const progress = '█'.repeat(Math.floor((current / total) * 20));
+        const empty = '░'.repeat(20 - progress.length);
+        console.log(`\n[${progress}${empty}] Step ${current}/${total}: ${step}`);
+    }
+
+    /**
+     * Display completion message
+     * @param {Object} result - Setup result
+     */
+    showCompletion(result) {
+        console.log('\n🎉 Setup Complete!');
+        console.log('='.repeat(20));
+        
+        if (result.success) {
+            console.log('✅ Claude Code toolkit has been successfully configured!');
+            console.log(`📦 Installed ${result.installedCount} commands`);
+            if (result.hooksInstalled) {
+                console.log('🔒 Security hooks installed');
+            }
+            if (result.configApplied) {
+                console.log('⚙️ Configuration template applied');
+            }
+        } else {
+            console.log('❌ Setup encountered issues:');
+            result.errors.forEach(error => console.log(`   • ${error}`));
+        }
+    }
+
+    /**
+     * Display error message
+     * @param {string} message - Error message
+     * @param {Error} error - Optional error object
+     */
+    showError(message, error = null) {
+        console.log(`\n❌ Error: ${message}`);
+        if (error && error.message) {
+            console.log(`   Details: ${error.message}`);
+        }
+    }
+
+    /**
+     * Display warning message
+     * @param {string} message - Warning message
+     */
+    showWarning(message) {
+        console.log(`\n⚠️ Warning: ${message}`);
+    }
+
+    /**
+     * Display info message
+     * @param {string} message - Info message
+     */
+    showInfo(message) {
+        console.log(`\nℹ️ ${message}`);
+    }
+}
+
+module.exports = SetupWizardUI;

package/lib/setup-wizard.js

@@ -0,0 +1,355 @@
+#!/usr/bin/env node
+
+/**
+ * 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');
+
+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'
+            }
+        ];
+    }
+    
+    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'
+            };
+        } catch (error) {
+            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;
+    }
+    
+    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)
+        };
+    }
+    
+    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;
+    }
+    
+    runNonInteractiveSetup() {
+        const defaultConfig = {
+            installationType: 'standard',
+            commandSets: ['development', 'planning'],
+            securityHooks: true,
+            selectedHooks: ['credential-protection'],
+            template: 'basic'
+        };
+        
+        this.saveConfiguration(defaultConfig);
+        
+        return {
+            completed: true,
+            configuration: defaultConfig
+        };
+    }
+    
+    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
+        };
+    }
+    
+    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'
+        };
+    }
+    
+    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'
+        };
+    }
+    
+    loadConfiguration() {
+        const configData = this.config.loadConfiguration();
+        if (configData) {
+            return {
+                found: true,
+                config: configData
+            };
+        }
+        return {
+            found: false
+        };
+    }
+    
+    async loadConfigurationAsync() {
+        const configData = await this.config.loadConfigurationAsync();
+        if (configData) {
+            return {
+                found: true,
+                config: configData
+            };
+        }
+        return {
+            found: false
+        };
+    }
+    
+    applyPreset(presetName) {
+        return this.commandSelector.applyPreset(presetName);
+    }
+    
+    async runInteractiveSetup() {
+        const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout
+        });
+        
+        const question = (prompt) => new Promise((resolve) => {
+            rl.question(prompt, resolve);
+        });
+        
+        console.log('\n🚀 Claude Dev Toolkit Interactive Setup Wizard');
+        console.log('=' .repeat(50));
+        
+        const config = {};
+        
+        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;
+                }
+            }
+            
+            console.log('\n✅ Setup completed successfully!');
+            console.log(`Configuration saved to: ${this.configFile}`);
+            
+            rl.close();
+            
+            return {
+                completed: true,
+                configuration: config
+            };
+            
+        } catch (error) {
+            rl.close();
+            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 };
+        }
+        
+        const wizard = new InteractiveSetupWizard(this.packageRoot);
+        return wizard.runNonInteractiveSetup();
+    }
+}
+
+// Export both classes
+module.exports = InteractiveSetupWizard;
+module.exports.PostInstaller = PostInstaller;