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

package/package.json

@@ -0,0 +1,73 @@
+{
+  "name": "@paulduvall/claude-dev-toolkit",
+  "version": "0.0.1-alpha.1",
+  "description": "Custom commands toolkit for Claude Code - streamline your development workflow",
+  "author": "Paul Duvall",
+  "license": "MIT",
+  "keywords": [
+    "claude-code",
+    "claude",
+    "ai",
+    "development",
+    "automation",
+    "commands"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/PaulDuvall/claude-code.git"
+  },
+  "bugs": {
+    "url": "https://github.com/PaulDuvall/claude-code/issues"
+  },
+  "homepage": "https://github.com/PaulDuvall/claude-code#readme",
+  "bin": {
+    "claude-commands": "bin/claude-commands"
+  },
+  "scripts": {
+    "postinstall": "node scripts/postinstall.js",
+    "test": "node tests/test_all_suites.js",
+    "test:req007": "node tests/test_req_007_interactive_setup_wizard.js",
+    "test:req009": "node tests/test_req_009_configuration_template_application.js",
+    "test:req018": "node tests/test_req_018_security_hook_installation.js",
+    "test:req020": "node tests/test_req_020_installation_failure_recovery.js",
+    "test:commands": "node tests/test_command_validation.js",
+    "test:workflow": "node tests/test_core_workflow_commands.js",
+    "test:security": "node tests/test_security_commands.js",
+    "test:quality": "node tests/test_quality_commands.js",
+    "test:git": "node tests/test_git_commands.js",
+    "test:ux": "node tests/test_user_experience.js",
+    "test:validation": "node tests/test_validation_system.js",
+    "test:install": "scripts/publishing/test-package-install.sh",
+    "test:manual": "scripts/publishing/manual-test-suite.sh",
+    "publish:local": "scripts/publishing/setup-local-registry.sh",
+    "publish:private": "scripts/publishing/publish-private.sh",
+    "lint": "eslint lib/**/*.js bin/**/*.js",
+    "validate": "node scripts/validate.js"
+  },
+  "dependencies": {
+    "commander": "^9.0.0",
+    "inquirer": "^8.2.7",
+    "js-yaml": "^4.1.0"
+  },
+  "devDependencies": {
+    "eslint": "^8.0.0",
+    "jest": "^29.0.0"
+  },
+  "engines": {
+    "node": ">=16.0.0"
+  },
+  "files": [
+    "bin/",
+    "lib/",
+    "commands/",
+    "templates/",
+    "hooks/",
+    "scripts/postinstall.js",
+    "scripts/validate.js",
+    "README.md",
+    "LICENSE"
+  ],
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/scripts/postinstall.js

@@ -0,0 +1,182 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { execSync } = require('child_process');
+
+// Check for skip flag
+const skipSetup = process.env.CLAUDE_SKIP_SETUP === 'true' || 
+                 process.argv.includes('--skip-setup');
+
+console.log('🚀 Setting up Claude Custom Commands...');
+
+async function runSetup() {
+    try {
+        // Get Claude Code directory
+        const homeDir = os.homedir();
+        const claudeDir = path.join(homeDir, '.claude');
+        const commandsDir = path.join(claudeDir, 'commands');
+        const hooksDir = path.join(claudeDir, 'hooks');
+        
+        // Ensure Claude directories exist
+        if (!fs.existsSync(claudeDir)) {
+            fs.mkdirSync(claudeDir, { recursive: true });
+            console.log('✅ Created .claude directory');
+        }
+        
+        if (!fs.existsSync(commandsDir)) {
+            fs.mkdirSync(commandsDir, { recursive: true });
+            console.log('✅ Created .claude/commands directory');
+        }
+        
+        if (!fs.existsSync(hooksDir)) {
+            fs.mkdirSync(hooksDir, { recursive: true });
+            console.log('✅ Created .claude/hooks directory');
+        }
+        
+        // Get package installation directory
+        const packageDir = __dirname.replace('/scripts', '');
+        
+        // Check if we should run interactive setup
+        if (!skipSetup && process.stdin.isTTY) {
+            console.log('\n📋 Starting Interactive Setup Wizard...');
+            console.log('(Use --skip-setup or set CLAUDE_SKIP_SETUP=true to skip)\n');
+            
+            const InteractiveSetupWizard = require('../lib/setup-wizard');
+            const wizard = new InteractiveSetupWizard(claudeDir);
+            
+            // Validate environment first (REQ-006)
+            const envCheck = wizard.validateEnvironment();
+            if (!envCheck.valid) {
+                console.error('❌ Environment validation failed:', envCheck.message);
+                process.exit(1);
+            }
+            
+            // Run interactive setup (REQ-007)
+            const setupResult = await wizard.runInteractiveSetup();
+            
+            if (setupResult.completed) {
+                const config = setupResult.configuration;
+                
+                // Install commands based on selection
+                const sourceCommandsDir = path.join(packageDir, 'commands');
+                if (fs.existsSync(sourceCommandsDir)) {
+                    copySelectedCommands(sourceCommandsDir, commandsDir, config);
+                }
+                
+                // Install security hooks if selected
+                if (config.securityHooks) {
+                    const sourceHooksDir = path.join(packageDir, 'hooks');
+                    if (fs.existsSync(sourceHooksDir)) {
+                        copySelectedHooks(sourceHooksDir, hooksDir, config.selectedHooks || []);
+                    }
+                }
+                
+                // Apply configuration template
+                if (config.template) {
+                    const templateFile = path.join(packageDir, 'templates', `${config.template}-settings.json`);
+                    const targetFile = path.join(claudeDir, 'settings.json');
+                    if (fs.existsSync(templateFile)) {
+                        fs.copyFileSync(templateFile, targetFile);
+                        console.log(`✅ Applied ${config.template} configuration template`);
+                    }
+                }
+            }
+        } else {
+            // Non-interactive installation - install all commands by default
+            console.log('Running non-interactive installation...');
+            
+            const sourceCommandsDir = path.join(packageDir, 'commands');
+            if (fs.existsSync(sourceCommandsDir)) {
+                copyAllCommands(sourceCommandsDir, commandsDir);
+            }
+        }
+        
+        // Count installed commands (now in flat structure)
+        if (fs.existsSync(commandsDir)) {
+            const installedCommands = fs.readdirSync(commandsDir).filter(f => f.endsWith('.md')).length;
+            console.log(`\n📦 Installed ${installedCommands} commands`);
+        }
+        
+        console.log('\n🎉 Installation complete!');
+        console.log('\nNext steps:');
+        console.log('1. Run: claude-commands list');
+        console.log('2. Try: claude-commands --help');
+        console.log('3. Configure: claude-commands config');
+        console.log('4. Explore commands in Claude Code using /xhelp\n');
+        
+    } catch (error) {
+        console.error('❌ Installation failed:', error.message);
+        process.exit(1);
+    }
+}
+
+function copyAllCommands(sourceDir, targetDir) {
+    const items = fs.readdirSync(sourceDir);
+    for (const item of items) {
+        const sourcePath = path.join(sourceDir, item);
+        const targetPath = path.join(targetDir, item);
+        
+        if (fs.statSync(sourcePath).isDirectory()) {
+            if (!fs.existsSync(targetPath)) {
+                fs.mkdirSync(targetPath, { recursive: true });
+            }
+            copyAllCommands(sourcePath, targetPath);
+        } else if (item.endsWith('.md')) {
+            fs.copyFileSync(sourcePath, targetPath);
+        }
+    }
+}
+
+function copySelectedCommands(sourceDir, targetDir, config) {
+    // Based on installation type, copy appropriate commands
+    const installationType = config.installationType || 'standard';
+    
+    if (installationType === 'full' || !config.commandSets) {
+        // Copy all commands
+        copyAllCommands(sourceDir, targetDir);
+    } else {
+        // Copy selected command sets
+        const commandSets = config.commandSets || [];
+        
+        // Always copy active commands for standard installation (flat structure)
+        if (installationType === 'standard' || commandSets.includes('development')) {
+            const activeSource = path.join(sourceDir, 'active');
+            if (fs.existsSync(activeSource)) {
+                copyAllCommands(activeSource, targetDir); // Copy directly to targetDir, no subdirectory
+            }
+        }
+        
+        // Copy experimental if selected (flat structure to avoid namespace)
+        if (commandSets.includes('experimental') || installationType === 'full') {
+            const expSource = path.join(sourceDir, 'experiments');
+            if (fs.existsSync(expSource)) {
+                copyAllCommands(expSource, targetDir); // Copy directly to targetDir, no subdirectory
+            }
+        }
+    }
+}
+
+function copySelectedHooks(sourceDir, targetDir, selectedHooks) {
+    const items = fs.readdirSync(sourceDir);
+    for (const item of items) {
+        const sourcePath = path.join(sourceDir, item);
+        
+        // Copy hook if it's selected or if no specific selection (copy all)
+        if (selectedHooks.length === 0 || selectedHooks.some(h => item.includes(h))) {
+            const targetPath = path.join(targetDir, item);
+            fs.copyFileSync(sourcePath, targetPath);
+            
+            // Make shell scripts executable
+            if (item.endsWith('.sh')) {
+                fs.chmodSync(targetPath, '755');
+            }
+            
+            console.log(`✅ Installed hook: ${item}`);
+        }
+    }
+}
+
+// Run the setup
+runSetup();

package/scripts/validate.js

@@ -0,0 +1,94 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+
+console.log('🔍 Validating Claude Custom Commands package...');
+
+let errors = 0;
+let warnings = 0;
+
+const log = (level, message) => {
+    const prefix = level === 'error' ? '❌' : level === 'warn' ? '⚠️' : '✅';
+    console.log(`${prefix} ${message}`);
+    if (level === 'error') errors++;
+    if (level === 'warn') warnings++;
+};
+
+try {
+    const packageDir = __dirname.replace('/scripts', '');
+    
+    // Check required directories
+    const requiredDirs = ['bin', 'lib', 'commands', 'commands/active', 'commands/experiments'];
+    requiredDirs.forEach(dir => {
+        const dirPath = path.join(packageDir, dir);
+        if (fs.existsSync(dirPath)) {
+            log('info', `Directory exists: ${dir}/`);
+        } else {
+            log('error', `Missing required directory: ${dir}/`);
+        }
+    });
+    
+    // Check required files
+    const requiredFiles = [
+        'package.json',
+        'README.md',
+        'bin/claude-commands',
+        'lib/config.js',
+        'lib/installer.js',
+        'lib/utils.js'
+    ];
+    
+    requiredFiles.forEach(file => {
+        const filePath = path.join(packageDir, file);
+        if (fs.existsSync(filePath)) {
+            log('info', `File exists: ${file}`);
+        } else {
+            log('error', `Missing required file: ${file}`);
+        }
+    });
+    
+    // Check bin file permissions
+    const binFile = path.join(packageDir, 'bin/claude-commands');
+    if (fs.existsSync(binFile)) {
+        const stats = fs.statSync(binFile);
+        const mode = (stats.mode & parseInt('777', 8)).toString(8);
+        if (mode.includes('7') || mode.includes('5')) {
+            log('info', `Binary is executable (${mode})`);
+        } else {
+            log('warn', `Binary may not be executable (${mode})`);
+        }
+    }
+    
+    // Count commands
+    const activeDir = path.join(packageDir, 'commands/active');
+    const experimentalDir = path.join(packageDir, 'commands/experiments');
+    
+    if (fs.existsSync(activeDir)) {
+        const activeCount = fs.readdirSync(activeDir).filter(f => f.endsWith('.md')).length;
+        log('info', `Found ${activeCount} active commands`);
+    }
+    
+    if (fs.existsSync(experimentalDir)) {
+        const expCount = fs.readdirSync(experimentalDir).filter(f => f.endsWith('.md')).length;
+        log('info', `Found ${expCount} experimental commands`);
+    }
+    
+    console.log('');
+    console.log(`📊 Validation Summary:`);
+    console.log(`   Errors: ${errors}`);
+    console.log(`   Warnings: ${warnings}`);
+    
+    if (errors > 0) {
+        console.log('');
+        console.log('❌ Package validation failed');
+        process.exit(1);
+    } else {
+        console.log('');
+        console.log('✅ Package validation passed');
+    }
+    
+} catch (error) {
+    console.error('❌ Validation failed:', error.message);
+    process.exit(1);
+}