claude-all-config 2.0.0

package/utils/install-superpowers.js

@@ -0,0 +1,411 @@
+#!/usr/bin/env node
+
+/**
+ * 🦸 Claude-All Superpowers Installer
+ * Menginstall skills, commands, agents, dan hooks ke Claude Code
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { execSync } = require('child_process');
+
+class SuperpowersInstaller {
+    constructor() {
+        this.homeDir = os.homedir();
+        this.packageDir = path.resolve(__dirname, '..');
+        this.superpowersDir = path.join(this.packageDir, 'superpowers');
+        this.claudeDir = path.join(this.homeDir, '.claude');
+
+        // Claude Code paths
+        this.claudePluginsDir = path.join(this.claudeDir, 'plugins', 'claude-all-superpowers');
+        this.claudeCommandsDir = path.join(this.claudeDir, 'commands');
+        this.claudeSkillsDir = path.join(this.claudePluginsDir, 'skills');
+        this.claudeGlobalSkillsDir = path.join(this.claudeDir, 'skills'); // Global skills folder
+        this.claudeAgentsDir = path.join(this.claudePluginsDir, 'agents');
+        this.claudeGlobalAgentsDir = path.join(this.claudeDir, 'agents'); // Global agents folder
+        this.claudeHooksDir = path.join(this.claudePluginsDir, 'hooks');
+        this.claudeLibDir = path.join(this.claudePluginsDir, 'lib');
+        this.claudeTestsDir = path.join(this.claudePluginsDir, 'tests');
+    }
+
+    printHeader() {
+        console.log('');
+        console.log('🦸 CLAUDE-ALL SUPERPOWERS INSTALLER');
+        console.log('===================================');
+        console.log('');
+        console.log('Installing superpowers to Claude Code:');
+        console.log('  ✅ Skills (specialized capabilities)');
+        console.log('  ✅ Commands (slash commands)');
+        console.log('  ✅ Agents (task automation)');
+        console.log('  ✅ Hooks (git hooks)');
+        console.log('  ✅ Libraries (helper functions)');
+        console.log('  ✅ Tests (test suites)');
+        console.log('');
+    }
+
+    checkPrerequisites() {
+        console.log('🔍 Checking prerequisites...');
+
+        // Check if Claude directory exists
+        if (!fs.existsSync(this.claudeDir)) {
+            console.log(`⚠️  Claude directory not found: ${this.claudeDir}`);
+            console.log('💡 Make sure Claude Code CLI is installed first');
+            return false;
+        }
+
+        // Check if superpowers directory exists
+        if (!fs.existsSync(this.superpowersDir)) {
+            console.log(`❌ Superpowers directory not found: ${this.superpowersDir}`);
+            return false;
+        }
+
+        console.log(`✅ Claude directory: ${this.claudeDir}`);
+        console.log(`✅ Superpowers source: ${this.superpowersDir}`);
+        return true;
+    }
+
+    createDirectories() {
+        console.log('');
+        console.log('📁 Creating directories...');
+
+        const dirs = [
+            this.claudePluginsDir,
+            this.claudeSkillsDir,
+            this.claudeAgentsDir,
+            this.claudeHooksDir,
+            this.claudeLibDir,
+            this.claudeCommandsDir
+        ];
+
+        dirs.forEach(dir => {
+            if (!fs.existsSync(dir)) {
+                fs.mkdirSync(dir, { recursive: true });
+                console.log(`  ✅ Created: ${path.basename(dir)}`);
+            } else {
+                console.log(`  ✓ Exists: ${path.basename(dir)}`);
+            }
+        });
+    }
+
+    copyDirectory(src, dest, name) {
+        if (!fs.existsSync(src)) {
+            console.log(`  ⚠️  Skipped ${name}: source not found`);
+            return 0;
+        }
+
+        let count = 0;
+
+        const copy = (source, destination) => {
+            const stat = fs.statSync(source);
+
+            if (stat.isDirectory()) {
+                const items = fs.readdirSync(source);
+                items.forEach(item => {
+                    copy(path.join(source, item), path.join(destination, item));
+                });
+            } else {
+                // Create destination directory if needed
+                const destDir = path.dirname(destination);
+                if (!fs.existsSync(destDir)) {
+                    fs.mkdirSync(destDir, { recursive: true });
+                }
+
+                fs.copyFileSync(source, destination);
+                count++;
+            }
+        };
+
+        copy(src, dest);
+        return count;
+    }
+
+    installSkills() {
+        console.log('');
+        console.log('🎯 Installing Skills...');
+
+        const skillsSource = path.join(this.superpowersDir, 'skills');
+        const skillsPluginDir = this.claudeSkillsDir;
+        const skillsGlobalDir = this.claudeGlobalSkillsDir;
+
+        if (!fs.existsSync(skillsSource)) {
+            console.log('  ⚠️  No skills directory found');
+            return;
+        }
+
+        // Ensure global skills directory exists
+        if (!fs.existsSync(skillsGlobalDir)) {
+            fs.mkdirSync(skillsGlobalDir, { recursive: true });
+        }
+
+        const skills = fs.readdirSync(skillsSource);
+        let count = 0;
+
+        skills.forEach(skill => {
+            const srcPath = path.join(skillsSource, skill);
+
+            // Copy to plugin skills directory
+            const destPath1 = path.join(skillsPluginDir, skill);
+            const numFiles1 = this.copyDirectory(srcPath, destPath1, skill);
+
+            // Also copy to global Claude skills directory (so they're available globally)
+            const destPath2 = path.join(skillsGlobalDir, skill);
+            const numFiles2 = this.copyDirectory(srcPath, destPath2, skill);
+
+            if (numFiles1 > 0) {
+                console.log(`  ✅ ${skill} (${numFiles1} files) → plugin & global`);
+                count++;
+            }
+        });
+
+        console.log(`📊 Total: ${count} skills installed (to both locations)`);
+    }
+
+    installCommands() {
+        console.log('');
+        console.log('⚡ Installing Commands...');
+
+        const commandsSource = path.join(this.superpowersDir, 'commands');
+        const commandsDest = this.claudeCommandsDir;
+
+        if (!fs.existsSync(commandsSource)) {
+            console.log('  ⚠️  No commands directory found');
+            return;
+        }
+
+        const commands = fs.readdirSync(commandsSource).filter(f => f.endsWith('.md'));
+        let count = 0;
+
+        commands.forEach(cmd => {
+            const srcPath = path.join(commandsSource, cmd);
+            const destPath = path.join(commandsDest, cmd);
+
+            fs.copyFileSync(srcPath, destPath);
+            console.log(`  ✅ /${cmd.replace('.md', '')}`);
+            count++;
+        });
+
+        console.log(`📊 Total: ${count} commands installed`);
+    }
+
+    installAgents() {
+        console.log('');
+        console.log('🤖 Installing Agents...');
+
+        const agentsSource = path.join(this.superpowersDir, 'agents');
+        const agentsPluginDir = this.claudeAgentsDir;
+        const agentsGlobalDir = this.claudeGlobalAgentsDir;
+
+        if (!fs.existsSync(agentsSource)) {
+            console.log('  ⚠️  No agents directory found');
+            return;
+        }
+
+        // Ensure global agents directory exists
+        if (!fs.existsSync(agentsGlobalDir)) {
+            fs.mkdirSync(agentsGlobalDir, { recursive: true });
+        }
+
+        const agents = fs.readdirSync(agentsSource);
+        let count = 0;
+
+        agents.forEach(agent => {
+            const srcPath = path.join(agentsSource, agent);
+
+            // Copy to plugin agents directory
+            const destPath1 = path.join(agentsPluginDir, agent);
+            fs.copyFileSync(srcPath, destPath1);
+
+            // Also copy to global Claude agents directory (so they're available globally)
+            const destPath2 = path.join(agentsGlobalDir, agent);
+            fs.copyFileSync(srcPath, destPath2);
+
+            console.log(`  ✅ ${agent} → plugin & global`);
+            count++;
+        });
+
+        console.log(`📊 Total: ${count} agents installed (to both locations)`);
+    }
+
+    installHooks() {
+        console.log('');
+        console.log('🪝 Installing Hooks...');
+
+        const hooksSource = path.join(this.superpowersDir, 'hooks');
+        const hooksDest = this.claudeHooksDir;
+        const claudeMainHooksDir = path.join(this.claudeDir, 'hooks');
+
+        if (!fs.existsSync(hooksSource)) {
+            console.log('  ⚠️  No hooks directory found');
+            return;
+        }
+
+        // Ensure main hooks directory exists
+        if (!fs.existsSync(claudeMainHooksDir)) {
+            fs.mkdirSync(claudeMainHooksDir, { recursive: true });
+        }
+
+        const hooks = fs.readdirSync(hooksSource);
+        let count = 0;
+
+        hooks.forEach(hook => {
+            const srcPath = path.join(hooksSource, hook);
+
+            // Copy to plugin hooks directory
+            const destPath1 = path.join(hooksDest, hook);
+            const numFiles1 = this.copyDirectory(srcPath, destPath1, hook);
+
+            // Also copy to main Claude hooks directory (so they can be executed)
+            const destPath2 = path.join(claudeMainHooksDir, hook);
+            const numFiles2 = this.copyDirectory(srcPath, destPath2, hook);
+
+            if (numFiles1 > 0) {
+                console.log(`  ✅ ${hook} (${numFiles1} files) → plugins & main hooks`);
+                count++;
+            }
+        });
+
+        console.log(`📊 Total: ${count} hooks installed (to both locations)`);
+    }
+
+    installLibs() {
+        console.log('');
+        console.log('📚 Installing Libraries...');
+
+        const libsSource = path.join(this.superpowersDir, 'lib');
+        const libsDest = this.claudeLibDir;
+
+        if (!fs.existsSync(libsSource)) {
+            console.log('  ⚠️  No lib directory found');
+            return;
+        }
+
+        const libs = fs.readdirSync(libsSource);
+        let count = 0;
+
+        libs.forEach(lib => {
+            const srcPath = path.join(libsSource, lib);
+            const destPath = path.join(libsDest, lib);
+
+            fs.copyFileSync(srcPath, destPath);
+            console.log(`  ✅ ${lib}`);
+            count++;
+        });
+
+        console.log(`📊 Total: ${count} libraries installed`);
+    }
+
+    installTests() {
+        console.log('');
+        console.log('🧪 Installing Tests...');
+
+        const testsSource = path.join(this.superpowersDir, 'tests');
+        const testsDest = this.claudeTestsDir;
+
+        if (!fs.existsSync(testsSource)) {
+            console.log('  ⚠️  No tests directory found');
+            return;
+        }
+
+        const testSuites = fs.readdirSync(testsSource);
+        let count = 0;
+
+        testSuites.forEach(suite => {
+            const srcPath = path.join(testsSource, suite);
+            const destPath = path.join(testsDest, suite);
+
+            const numFiles = this.copyDirectory(srcPath, destPath, suite);
+            if (numFiles > 0) {
+                console.log(`  ✅ ${suite} (${numFiles} files)`);
+                count++;
+            }
+        });
+
+        console.log(`📊 Total: ${count} test suites installed`);
+    }
+
+    createManifest() {
+        console.log('');
+        console.log('📋 Creating manifest...');
+
+        const manifest = {
+            name: 'claude-all-superpowers',
+            version: fs.readFileSync(path.join(this.packageDir, 'VERSION'), 'utf8').trim(),
+            description: 'Claude-All Superpowers Collection',
+            installedAt: new Date().toISOString(),
+            components: {
+                skills: fs.existsSync(this.claudeSkillsDir) ? fs.readdirSync(this.claudeSkillsDir).length : 0,
+                commands: fs.existsSync(this.claudeCommandsDir) ? fs.readdirSync(this.claudeCommandsDir).filter(f => f.endsWith('.md')).length : 0,
+                agents: fs.existsSync(this.claudeAgentsDir) ? fs.readdirSync(this.claudeAgentsDir).length : 0,
+                hooks: fs.existsSync(this.claudeHooksDir) ? fs.readdirSync(this.claudeHooksDir).length : 0,
+                libs: fs.existsSync(this.claudeLibDir) ? fs.readdirSync(this.claudeLibDir).length : 0,
+                tests: fs.existsSync(this.claudeTestsDir) ? fs.readdirSync(this.claudeTestsDir).length : 0
+            }
+        };
+
+        const manifestPath = path.join(this.claudePluginsDir, 'manifest.json');
+        fs.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2));
+        console.log(`  ✅ Manifest created: ${manifestPath}`);
+    }
+
+    showCompletion() {
+        console.log('');
+        console.log('🎉 SUPERPOWERS INSTALLATION COMPLETED!');
+        console.log('=====================================');
+        console.log('');
+        console.log('✅ All superpowers installed to Claude Code');
+        console.log('');
+        console.log('📍 Installation Location:');
+        console.log(`   ${this.claudePluginsDir}`);
+        console.log('');
+        console.log('🚀 Usage:');
+        console.log('   Restart Claude Code CLI to load superpowers');
+        console.log('');
+        console.log('📚 Available Superpowers:');
+        console.log('   • Skills - Specialized capabilities');
+        console.log('   • Commands - Slash commands');
+        console.log('   • Agents - Task automation');
+        console.log('   • Hooks - Git hooks');
+        console.log('   • Libraries - Helper functions');
+        console.log('   • Tests - Test suites');
+        console.log('');
+        console.log('💡 Tip: Use /help in Claude Code to see available commands');
+        console.log('');
+    }
+
+    async install() {
+        try {
+            this.printHeader();
+
+            if (!this.checkPrerequisites()) {
+                console.log('');
+                console.log('❌ Installation failed: Prerequisites not met');
+                process.exit(1);
+            }
+
+            this.createDirectories();
+            this.installSkills();
+            this.installCommands();
+            this.installAgents();
+            this.installHooks();
+            this.installLibs();
+            this.installTests();
+            this.createManifest();
+            this.showCompletion();
+
+        } catch (error) {
+            console.error('');
+            console.error('❌ Installation failed:', error.message);
+            console.error(error.stack);
+            process.exit(1);
+        }
+    }
+}
+
+// Run installer if called directly
+if (require.main === module) {
+    const installer = new SuperpowersInstaller();
+    installer.install();
+}
+
+module.exports = SuperpowersInstaller;

package/utils/install.js

@@ -0,0 +1,298 @@
+#!/usr/bin/env node
+
+/**
+ * 🤖 Claude-All Universal AI Launcher - NPM Installer
+ * Cross-platform installer for AI CLI launcher with multiple providers
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+const os = require('os');
+
+class ClaudeAllInstaller {
+    constructor() {
+        this.homeDir = os.homedir();
+        this.platform = os.platform();
+        this.packageDir = __dirname;
+        this.installDir = path.join(this.homeDir, '.claude-all');
+    }
+
+    printHeader() {
+        console.log('🤖 CLAUDE-ALL UNIVERSAL AI LAUNCHER');
+        console.log('==================================');
+        console.log('Installing AI CLI launcher with:');
+        console.log('  ✅ Claude Code CLI integration');
+        console.log('  ✅ Multiple AI providers (MiniMax, Gemini, OpenAI, Groq, Ollama)');
+        console.log('  ✅ Universal device compatibility');
+        console.log('  ✅ Cross-platform support');
+        console.log('');
+    }
+
+    checkSystem() {
+        console.log('🔍 Checking system compatibility...');
+
+        const supportedPlatforms = ['linux', 'darwin', 'win32', 'freebsd', 'openbsd', 'android', 'sunos'];
+        if (!supportedPlatforms.includes(this.platform)) {
+            console.log(`⚠️  Platform ${this.platform} not officially supported`);
+            console.log('  Trying installation anyway...');
+        } else {
+            console.log(`✅ Platform: ${this.platform}`);
+        }
+
+        // Check Node.js version
+        const nodeVersion = process.version;
+        const majorVersion = parseInt(nodeVersion.slice(1).split('.')[0]);
+        if (majorVersion < 14) {
+            console.log(`⚠️  Node.js ${nodeVersion} detected. Minimum recommended: 14.x`);
+        } else {
+            console.log(`✅ Node.js: ${nodeVersion}`);
+        }
+    }
+
+    createDirectories() {
+        console.log('📁 Creating directories...');
+
+        const dirs = [
+            this.installDir,
+            path.join(this.installDir, 'config'),
+            path.join(this.installDir, 'logs'),
+            path.join(this.installDir, 'cache')
+        ];
+
+        dirs.forEach(dir => {
+            if (!fs.existsSync(dir)) {
+                fs.mkdirSync(dir, { recursive: true });
+                console.log(`  ✅ Created: ${dir}`);
+            }
+        });
+    }
+
+    installDependencies() {
+        console.log('📦 Checking dependencies...');
+
+        const commands = {
+            linux: [
+                'curl --version',
+                'wget --version',
+                'python3 --version'
+            ],
+            darwin: [
+                'curl --version',
+                'wget --version',
+                'python3 --version'
+            ],
+            win32: [
+                'curl --version',
+                'python --version'
+            ],
+            android: [
+                'curl --version',
+                'python --version'
+            ]
+        };
+
+        const platformCommands = commands[this.platform] || commands.linux;
+
+        platformCommands.forEach(cmd => {
+            try {
+                execSync(cmd, { stdio: 'pipe' });
+                console.log(`  ✅ ${cmd.split(' ')[0]} available`);
+            } catch (e) {
+                console.log(`  ⚠️  ${cmd.split(' ')[0]} not found (optional)`);
+            }
+        });
+    }
+
+    setupConfiguration() {
+        console.log('⚙️  Setting up configuration...');
+
+        const defaultConfig = {
+            version: fs.readFileSync(path.join(this.packageDir, '..', 'VERSION'), 'utf8').trim(),
+            providers: {
+                minimax: {
+                    name: "MiniMax",
+                    enabled: true,
+                    endpoint: "https://api.minimax.chat/v1",
+                    models: ["abab6.5", "abab6.5s", "abab5.5"]
+                },
+                gemini: {
+                    name: "Google Gemini",
+                    enabled: true,
+                    endpoint: "https://generativelanguage.googleapis.com/v1beta",
+                    models: ["gemini-pro", "gemini-pro-vision"]
+                },
+                openai: {
+                    name: "OpenAI",
+                    enabled: true,
+                    endpoint: "https://api.openai.com/v1",
+                    models: ["gpt-4", "gpt-3.5-turbo"]
+                },
+                groq: {
+                    name: "Groq",
+                    enabled: true,
+                    endpoint: "https://api.groq.com/openai/v1",
+                    models: ["llama-3.1-70b-versatile", "mixtral-8x7b-32768"]
+                }
+            },
+            ui: {
+                theme: "default",
+                auto_save: true,
+                history_size: 1000
+            }
+        };
+
+        const configFile = path.join(this.installDir, 'config', 'config.json');
+        fs.writeFileSync(configFile, JSON.stringify(defaultConfig, null, 2));
+        console.log(`  ✅ Configuration: ${configFile}`);
+    }
+
+    createSymlinks() {
+        console.log('🔗 Creating symlinks...');
+
+        const binDir = path.join(this.homeDir, '.local', 'bin');
+        if (!fs.existsSync(binDir)) {
+            fs.mkdirSync(binDir, { recursive: true });
+        }
+
+        const targets = [
+            { src: 'claude-all', dest: 'claude-all' },
+            { src: 'claude-all', dest: 'claude-launcher' },
+            { src: 'claude-all', dest: 'ai-chat' }
+        ];
+
+        targets.forEach(({ src, dest }) => {
+            const sourcePath = path.join(this.packageDir, '..', 'bin', src);
+            const destPath = path.join(binDir, dest);
+
+            try {
+                if (fs.existsSync(destPath)) {
+                    fs.unlinkSync(destPath);
+                }
+
+                if (this.platform === 'win32') {
+                    fs.copyFileSync(sourcePath, destPath);
+                    fs.chmodSync(destPath, '755');
+                } else {
+                    fs.symlinkSync(sourcePath, destPath);
+                }
+
+                console.log(`  ✅ ${dest}`);
+            } catch (e) {
+                console.log(`  ⚠️  Could not create ${dest}: ${e.message}`);
+            }
+        });
+    }
+
+    updateShellConfig() {
+        console.log('🔧 Updating shell configuration...');
+
+        const shellFiles = ['.bashrc', '.zshrc', '.profile'];
+        const binPath = path.join(this.homeDir, '.local', 'bin');
+        const exportLine = `export PATH="${binPath}:$PATH"`;
+
+        shellFiles.forEach(file => {
+            const filePath = path.join(this.homeDir, file);
+
+            if (fs.existsSync(filePath)) {
+                const content = fs.readFileSync(filePath, 'utf8');
+
+                if (!content.includes(binPath)) {
+                    fs.appendFileSync(filePath, `\n\n# Claude-All AI Launcher\n${exportLine}\n`);
+                    console.log(`  ✅ Updated ${file}`);
+                }
+            }
+        });
+
+        console.log(`  💡 Add to PATH: ${binPath}`);
+    }
+
+    createStartupScripts() {
+        console.log('🚀 Creating startup scripts...');
+
+        const launchScript = `#!/bin/bash
+# Claude-All AI Launcher
+echo "🤖 Starting Claude-All AI Launcher..."
+exec "${path.join(this.packageDir, '..', 'bin', 'claude-all')}" "$@"
+`;
+
+        const scripts = {
+            'claude-launch': launchScript,
+            'ai-chat': launchScript
+        };
+
+        Object.entries(scripts).forEach(([name, content]) => {
+            const scriptPath = path.join(this.installDir, name);
+            fs.writeFileSync(scriptPath, content);
+            fs.chmodSync(scriptPath, '755');
+            console.log(`  ✅ ${scriptPath}`);
+        });
+    }
+
+    showCompletion() {
+        console.log('');
+        console.log('🎉 CLAUDE-ALL INSTALLATION COMPLETED!');
+        console.log('====================================');
+        console.log('');
+        console.log('✅ Universal AI launcher installed');
+        console.log('✅ Multiple AI providers configured');
+        console.log('✅ Cross-platform compatibility ensured');
+        console.log('✅ Shell configuration updated');
+        console.log('');
+        console.log('🚀 Quick Start:');
+        console.log('');
+        console.log('NPM Commands:');
+        console.log('  npm run claude         - Start Claude-All');
+        console.log('  npm run launch         - Start Claude-All');
+        console.log('  npm run switch         - Switch AI provider');
+        console.log('  npm run config         - Configure settings');
+        console.log('  npm run help           - Show help');
+        console.log('');
+        console.log('Direct Commands:');
+        console.log('  claude-all              - Start AI launcher');
+        console.log('  ai-chat                 - Start chat interface');
+        console.log('  claude-launcher         - Alternative launcher');
+        console.log('');
+        console.log('🔧 Configuration:');
+        console.log(`  Config: ${path.join(this.installDir, 'config', 'config.json')}`);
+        console.log(`  Logs:   ${path.join(this.installDir, 'logs')}`);
+        console.log('');
+        console.log('📱 Supported Providers:');
+        console.log('  • MiniMax                • Google Gemini');
+        console.log('  • OpenAI                 • Groq');
+        console.log('  • Ollama (Local)         • Custom APIs');
+        console.log('  • xAI/Grok               • ZhipuAI/GLM');
+        console.log('');
+        console.log('⚠️  IMPORTANT:');
+        console.log('  • Restart your shell or run: source ~/.bashrc');
+        console.log('  • Set API keys in configuration');
+        console.log('  • Run: npm run config to setup');
+        console.log('');
+        console.log('🎯 Ready to launch AI assistants on any device! 🚀');
+    }
+
+    async install() {
+        try {
+            this.printHeader();
+            this.checkSystem();
+            this.createDirectories();
+            this.installDependencies();
+            this.setupConfiguration();
+            this.createSymlinks();
+            this.updateShellConfig();
+            this.createStartupScripts();
+            this.showCompletion();
+        } catch (error) {
+            console.error('❌ Installation failed:', error.message);
+            process.exit(1);
+        }
+    }
+}
+
+// Run installer if called directly
+if (require.main === module) {
+    const installer = new ClaudeAllInstaller();
+    installer.install();
+}
+
+module.exports = ClaudeAllInstaller;