@paulduvall/claude-dev-toolkit 0.0.1-alpha.7 → 0.0.1-alpha.9

package/lib/setup-command.js

@@ -0,0 +1,309 @@
+#!/usr/bin/env node
+
+/**
+ * Setup Command Implementation
+ * Replaces setup.sh functionality with npm package equivalent
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { execSync } = require('child_process');
+
+class SetupCommand {
+    constructor() {
+        this.homeDir = process.env.TEST_HOME || os.homedir();
+        this.claudeDir = path.join(this.homeDir, '.claude');
+        this.commandsDir = path.join(this.claudeDir, 'commands');
+        this.settingsFile = path.join(this.claudeDir, 'settings.json');
+    }
+
+    /**
+     * Execute setup with options
+     */
+    async execute(options = {}) {
+        console.log('🚀 Claude Dev Toolkit Setup\n');
+        
+        const {
+            type = 'basic',
+            commands = 'active',
+            skipConfigure = false,
+            skipHooks = false,
+            force = false,
+            dryRun = false
+        } = options;
+
+        if (dryRun) {
+            return this.showDryRun(options);
+        }
+
+        try {
+            // 1. Verify Claude Code availability (optional check)
+            this.checkClaudeCode();
+
+            // 2. Create directory structure
+            await this.createDirectoryStructure(force);
+
+            // 3. Install commands
+            if (commands !== 'none') {
+                await this.installCommands(commands);
+            }
+
+            // 4. Apply configuration template
+            if (!skipConfigure) {
+                await this.applyConfigurationTemplate(type);
+            }
+
+            // 5. Install hooks (if requested)
+            if (!skipHooks) {
+                await this.installHooks();
+            }
+
+            // 6. Verify installation
+            await this.verifySetup();
+
+            console.log('\n✅ Setup completed successfully!');
+            console.log('\n💡 Next steps:');
+            console.log('   • Run: claude-commands verify');
+            console.log('   • Try: /xhelp in Claude Code to see all commands');
+
+            return { success: true, message: 'Setup completed successfully' };
+
+        } catch (error) {
+            console.error(`\n❌ Setup failed: ${error.message}`);
+            return { success: false, error: error.message };
+        }
+    }
+
+    /**
+     * Show dry run preview
+     */
+    showDryRun(options) {
+        console.log('🔍 Dry Run - Preview of setup actions:\n');
+        
+        console.log('📁 Directory Structure:');
+        console.log(`   • Create: ${this.claudeDir}`);
+        console.log(`   • Create: ${this.commandsDir}`);
+        
+        if (!options.skipConfigure) {
+            console.log('\n⚙️  Configuration:');
+            console.log(`   • Apply template: ${options.type || 'basic'}`);
+            console.log(`   • Create: ${this.settingsFile}`);
+        }
+        
+        console.log('\n📦 Commands Installation:');
+        const commandSet = options.commands || 'active';
+        console.log(`   • Install: ${commandSet} command set`);
+        
+        if (!options.skipHooks) {
+            console.log('\n🎣 Hooks:');
+            console.log('   • Install security hooks');
+            console.log('   • Configure file logging');
+        }
+        
+        console.log('\n🔍 Verification:');
+        console.log('   • Check installation completeness');
+        console.log('   • Validate configuration');
+        
+        console.log('\n💡 This was a dry run - no changes were made');
+        console.log('   Run without --dry-run to execute setup');
+        
+        return { success: true, dryRun: true };
+    }
+
+    /**
+     * Check Claude Code availability
+     */
+    checkClaudeCode() {
+        console.log('🔍 Checking Claude Code availability...');
+        
+        try {
+            execSync('claude --version', { stdio: 'pipe' });
+            console.log('   ✅ Claude Code detected');
+        } catch (error) {
+            console.log('   ⚠️  Claude Code not detected (optional)');
+            console.log('   💡 Install with: npm install -g @anthropic-ai/claude-code');
+        }
+    }
+
+    /**
+     * Create directory structure
+     */
+    async createDirectoryStructure(force) {
+        console.log('📁 Creating directory structure...');
+        
+        // Check if directories already exist
+        if (fs.existsSync(this.claudeDir) && !force) {
+            console.log('   ✅ ~/.claude directory already exists');
+        } else {
+            fs.mkdirSync(this.claudeDir, { recursive: true });
+            console.log(`   ✅ Created: ${this.claudeDir}`);
+        }
+        
+        if (!fs.existsSync(this.commandsDir)) {
+            fs.mkdirSync(this.commandsDir, { recursive: true });
+            console.log(`   ✅ Created: ${this.commandsDir}`);
+        } else {
+            console.log('   ✅ Commands directory already exists');
+        }
+    }
+
+    /**
+     * Install commands
+     */
+    async installCommands(commandSet) {
+        console.log(`📦 Installing ${commandSet} commands...`);
+        
+        try {
+            const installer = require('./installer');
+            const options = {};
+            
+            switch (commandSet) {
+                case 'active':
+                    options.active = true;
+                    break;
+                case 'experiments':
+                    options.experiments = true;
+                    break;
+                case 'all':
+                    options.all = true;
+                    break;
+                default:
+                    options.active = true;
+            }
+            
+            await installer.install(options);
+            console.log('   ✅ Commands installed successfully');
+        } catch (error) {
+            throw new Error(`Command installation failed: ${error.message}`);
+        }
+    }
+
+    /**
+     * Apply configuration template
+     */
+    async applyConfigurationTemplate(templateName) {
+        console.log(`⚙️  Applying ${templateName} configuration template...`);
+        
+        try {
+            const config = require('./config');
+            await config.applyTemplate(templateName);
+            console.log('   ✅ Configuration template applied');
+        } catch (error) {
+            console.log(`   ⚠️  Configuration template application failed: ${error.message}`);
+            // Don't fail setup for configuration issues
+        }
+    }
+
+    /**
+     * Install hooks
+     */
+    async installHooks() {
+        console.log('🎣 Installing hooks...');
+        
+        try {
+            // Check if hooks installer is available
+            const hooksInstaller = require('./hook-installer');
+            await hooksInstaller.install();
+            console.log('   ✅ Hooks installed successfully');
+        } catch (error) {
+            console.log(`   ⚠️  Hooks installation skipped: ${error.message}`);
+            // Don't fail setup for hooks
+        }
+    }
+
+    /**
+     * Verify setup completion
+     */
+    async verifySetup() {
+        console.log('🔍 Verifying setup...');
+        
+        const issues = [];
+        
+        // Check directory structure
+        if (!fs.existsSync(this.claudeDir)) {
+            issues.push('Claude directory not found');
+        }
+        
+        if (!fs.existsSync(this.commandsDir)) {
+            issues.push('Commands directory not found');
+        }
+        
+        // Check command installation
+        try {
+            const commands = fs.readdirSync(this.commandsDir).filter(f => f.endsWith('.md'));
+            if (commands.length === 0) {
+                issues.push('No commands installed');
+            } else {
+                console.log(`   ✅ ${commands.length} commands installed`);
+            }
+        } catch (error) {
+            issues.push('Cannot read commands directory');
+        }
+        
+        // Check configuration
+        if (fs.existsSync(this.settingsFile)) {
+            console.log('   ✅ Configuration file present');
+        } else {
+            console.log('   ⚠️  No configuration file (will use defaults)');
+        }
+        
+        if (issues.length > 0) {
+            console.log('   ⚠️  Issues detected:');
+            issues.forEach(issue => console.log(`      • ${issue}`));
+            throw new Error(`Setup verification failed: ${issues.join(', ')}`);
+        }
+        
+        console.log('   ✅ Setup verification passed');
+    }
+
+    /**
+     * Get available templates
+     */
+    getAvailableTemplates() {
+        const templatesDir = path.join(__dirname, '..', 'templates');
+        try {
+            return fs.readdirSync(templatesDir)
+                .filter(f => f.endsWith('.json'))
+                .map(f => f.replace('.json', ''));
+        } catch (error) {
+            return ['basic', 'comprehensive', 'security-focused'];
+        }
+    }
+
+    /**
+     * Get help text for setup command
+     */
+    getHelpText() {
+        return `
+Setup the Claude Dev Toolkit with custom commands and configuration.
+
+This command replaces the functionality of setup.sh script, providing
+a complete installation and configuration of the Claude Code toolkit.
+
+Usage:
+  claude-commands setup [options]
+
+Options:
+  --type <template>         Configuration template to apply
+                           (basic, comprehensive, security-focused)
+  --commands <set>         Command set to install 
+                           (active, experiments, all, none)
+  --skip-configure         Skip configuration step
+  --skip-hooks            Skip hooks installation  
+  --force                 Overwrite existing installation
+  --dry-run              Preview actions without executing
+
+Examples:
+  claude-commands setup
+  claude-commands setup --type comprehensive --commands all
+  claude-commands setup --dry-run
+  claude-commands setup --type security-focused --skip-hooks
+
+This command performs the equivalent of running setup.sh with intelligent
+defaults and enhanced error handling.
+        `.trim();
+    }
+}
+
+module.exports = SetupCommand;

package/lib/utils/claude-path-config.js

@@ -0,0 +1,184 @@
+/**
+ * Claude Path Configuration
+ * Centralized path management for Claude Code directories
+ */
+
+const path = require('path');
+const os = require('os');
+
+class ClaudePathConfig {
+    constructor(homeDir = os.homedir()) {
+        this.homeDir = homeDir;
+    }
+
+    /**
+     * Main Claude directory
+     */
+    get claudeDir() {
+        return path.join(this.homeDir, '.claude');
+    }
+
+    /**
+     * Commands directory
+     */
+    get commandsDir() {
+        return path.join(this.claudeDir, 'commands');
+    }
+
+    /**
+     * Settings file path
+     */
+    get settingsPath() {
+        return path.join(this.claudeDir, 'settings.json');
+    }
+
+    /**
+     * Backups directory
+     */
+    get backupsDir() {
+        return path.join(this.claudeDir, 'backups');
+    }
+
+    /**
+     * Settings backups directory
+     */
+    get settingsBackupsDir() {
+        return path.join(this.backupsDir, 'settings');
+    }
+
+    /**
+     * Commands backups directory
+     */
+    get commandsBackupsDir() {
+        return path.join(this.backupsDir, 'commands');
+    }
+
+    /**
+     * Hooks directory
+     */
+    get hooksDir() {
+        return path.join(this.claudeDir, 'hooks');
+    }
+
+    /**
+     * Subagents directory
+     */
+    get subagentsDir() {
+        return path.join(this.claudeDir, 'subagents');
+    }
+
+    /**
+     * Templates directory (in package)
+     */
+    get templatesDir() {
+        return path.join(__dirname, '..', '..', 'templates');
+    }
+
+    /**
+     * Package commands directory (active)
+     */
+    get packageActiveCommandsDir() {
+        return path.join(__dirname, '..', '..', 'commands', 'active');
+    }
+
+    /**
+     * Package commands directory (experiments)
+     */
+    get packageExperimentalCommandsDir() {
+        return path.join(__dirname, '..', '..', 'commands', 'experiments');
+    }
+
+    /**
+     * Package hooks directory
+     */
+    get packageHooksDir() {
+        return path.join(__dirname, '..', '..', 'hooks');
+    }
+
+    /**
+     * Package subagents directory
+     */
+    get packageSubagentsDir() {
+        return path.join(__dirname, '..', '..', 'subagents');
+    }
+
+    /**
+     * Get all user directories that might need creation
+     */
+    getUserDirectories() {
+        return [
+            this.claudeDir,
+            this.commandsDir,
+            this.backupsDir,
+            this.settingsBackupsDir,
+            this.commandsBackupsDir,
+            this.hooksDir,
+            this.subagentsDir
+        ];
+    }
+
+    /**
+     * Get all package directories for validation
+     */
+    getPackageDirectories() {
+        return [
+            this.templatesDir,
+            this.packageActiveCommandsDir,
+            this.packageExperimentalCommandsDir,
+            this.packageHooksDir,
+            this.packageSubagentsDir
+        ];
+    }
+
+    /**
+     * Create a backup path with timestamp
+     */
+    createBackupPath(name, type = 'general') {
+        const timestamp = new Date().toISOString().replace(/[:.]/g, '-').split('.')[0];
+        const backupName = name || `backup-${timestamp}`;
+        
+        switch (type) {
+            case 'settings':
+                return path.join(this.settingsBackupsDir, `${backupName}.json`);
+            case 'commands':
+                return path.join(this.commandsBackupsDir, backupName);
+            default:
+                return path.join(this.backupsDir, backupName);
+        }
+    }
+
+    /**
+     * Resolve template path from name
+     */
+    resolveTemplatePath(templateName) {
+        const variations = [
+            templateName,
+            `${templateName}.json`,
+            `${templateName}-settings.json`
+        ];
+
+        // Common aliases
+        const aliases = {
+            'basic': 'basic-settings.json',
+            'comprehensive': 'comprehensive-settings.json',
+            'security': 'security-focused-settings.json',
+            'security-focused': 'security-focused-settings.json'
+        };
+
+        if (aliases[templateName]) {
+            variations.unshift(aliases[templateName]);
+        }
+
+        for (const variant of variations) {
+            const fullPath = path.join(this.templatesDir, variant);
+            const fs = require('fs');
+            if (fs.existsSync(fullPath)) {
+                return fullPath;
+            }
+        }
+
+        return null;
+    }
+}
+
+module.exports = ClaudePathConfig;

package/lib/utils/file-system-utils.js

@@ -0,0 +1,152 @@
+/**
+ * File System Utilities
+ * Extracted common file system operations used across commands
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+class FileSystemUtils {
+    /**
+     * Format file size for human-readable display
+     */
+    static formatSize(bytes) {
+        const units = ['B', 'KB', 'MB', 'GB'];
+        let size = bytes;
+        let unitIndex = 0;
+        
+        while (size >= 1024 && unitIndex < units.length - 1) {
+            size /= 1024;
+            unitIndex++;
+        }
+        
+        return `${size.toFixed(2)} ${units[unitIndex]}`;
+    }
+
+    /**
+     * Calculate directory size recursively
+     */
+    static getDirectorySize(dirPath) {
+        let size = 0;
+        
+        try {
+            const entries = fs.readdirSync(dirPath);
+            entries.forEach(entry => {
+                const fullPath = path.join(dirPath, entry);
+                const stats = fs.statSync(fullPath);
+                
+                if (stats.isDirectory()) {
+                    size += this.getDirectorySize(fullPath);
+                } else {
+                    size += stats.size;
+                }
+            });
+        } catch (error) {
+            // Ignore errors and return partial size
+        }
+        
+        return size;
+    }
+
+    /**
+     * Ensure directory exists with proper permissions
+     */
+    static ensureDirectory(dirPath, mode = 0o755) {
+        if (!fs.existsSync(dirPath)) {
+            fs.mkdirSync(dirPath, { recursive: true, mode });
+        }
+    }
+
+    /**
+     * Copy file with error handling
+     */
+    static copyFile(source, destination, mode = 0o644) {
+        try {
+            fs.copyFileSync(source, destination);
+            fs.chmodSync(destination, mode);
+            return true;
+        } catch (error) {
+            return false;
+        }
+    }
+
+    /**
+     * Check if path exists and is readable
+     */
+    static isReadable(filePath) {
+        try {
+            fs.accessSync(filePath, fs.constants.R_OK);
+            return true;
+        } catch (error) {
+            return false;
+        }
+    }
+
+    /**
+     * Check if path exists and is writable
+     */
+    static isWritable(filePath) {
+        try {
+            fs.accessSync(filePath, fs.constants.W_OK);
+            return true;
+        } catch (error) {
+            return false;
+        }
+    }
+
+    /**
+     * Get file stats safely
+     */
+    static getStats(filePath) {
+        try {
+            return fs.statSync(filePath);
+        } catch (error) {
+            return null;
+        }
+    }
+
+    /**
+     * Read file safely with encoding
+     */
+    static readFile(filePath, encoding = 'utf8') {
+        try {
+            return fs.readFileSync(filePath, encoding);
+        } catch (error) {
+            return null;
+        }
+    }
+
+    /**
+     * Write file safely with mode
+     */
+    static writeFile(filePath, content, mode = 0o644) {
+        try {
+            fs.writeFileSync(filePath, content, { mode });
+            return true;
+        } catch (error) {
+            return false;
+        }
+    }
+
+    /**
+     * Remove file or directory safely
+     */
+    static remove(targetPath) {
+        try {
+            if (fs.existsSync(targetPath)) {
+                const stats = fs.statSync(targetPath);
+                if (stats.isDirectory()) {
+                    fs.rmSync(targetPath, { recursive: true, force: true });
+                } else {
+                    fs.unlinkSync(targetPath);
+                }
+            }
+            return true;
+        } catch (error) {
+            return false;
+        }
+    }
+}
+
+module.exports = FileSystemUtils;

package/lib/utils.js

@@ -1,15 +1,19 @@
 // Utility functions for Claude Dev Toolkit
 const path = require('path');
 const fs = require('fs');
+const FileSystemUtils = require('./utils/file-system-utils');
 
 module.exports = {
+    // Keep backward compatibility
     ensureDirectory: (dirPath) => {
-        if (!fs.existsSync(dirPath)) {
-            fs.mkdirSync(dirPath, { recursive: true });
-        }
+        FileSystemUtils.ensureDirectory(dirPath);
     },
     
     isValidCommand: (commandName) => {
         return /^[a-z][a-z0-9-]*$/.test(commandName);
-    }
+    },
+
+    // Export new utilities for migration
+    FileSystemUtils,
+    ClaudePathConfig: require('./utils/claude-path-config')
 };