claude-all-config 2.0.0

package/utils/config.js

@@ -0,0 +1,185 @@
+#!/usr/bin/env node
+
+/**
+ * 🤖 Claude-All Configuration Manager
+ */
+
+const fs = require('fs');
+const path = require('path');
+const readline = require('readline');
+
+class ConfigManager {
+    constructor() {
+        this.homeDir = require('os').homedir();
+        this.configDir = path.join(this.homeDir, '.claude-all', 'config');
+        this.configFile = path.join(this.configDir, 'config.json');
+        this.rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout
+        });
+    }
+
+    async question(prompt) {
+        return new Promise((resolve) => {
+            this.rl.question(prompt, resolve);
+        });
+    }
+
+    loadConfig() {
+        if (fs.existsSync(this.configFile)) {
+            return JSON.parse(fs.readFileSync(this.configFile, 'utf8'));
+        }
+        return this.getDefaultConfig();
+    }
+
+    getDefaultConfig() {
+        return {
+            version: "8.1.0",
+            providers: {
+                minimax: {
+                    name: "MiniMax",
+                    enabled: true,
+                    endpoint: "https://api.minimax.chat/v1",
+                    models: ["abab6.5", "abab6.5s", "abab5.5"],
+                    api_key: ""
+                },
+                gemini: {
+                    name: "Google Gemini",
+                    enabled: true,
+                    endpoint: "https://generativelanguage.googleapis.com/v1beta",
+                    models: ["gemini-pro", "gemini-pro-vision"],
+                    api_key: ""
+                },
+                openai: {
+                    name: "OpenAI",
+                    enabled: true,
+                    endpoint: "https://api.openai.com/v1",
+                    models: ["gpt-4", "gpt-3.5-turbo"],
+                    api_key: ""
+                },
+                groq: {
+                    name: "Groq",
+                    enabled: true,
+                    endpoint: "https://api.groq.com/openai/v1",
+                    models: ["llama-3.1-70b-versatile", "mixtral-8x7b-32768"],
+                    api_key: ""
+                }
+            },
+            ui: {
+                theme: "default",
+                auto_save: true,
+                history_size: 1000
+            },
+            default_provider: "minimax"
+        };
+    }
+
+    async setupProvider(providerName, providerConfig) {
+        console.log(`\n🔧 Configuring ${providerConfig.name}...`);
+
+        const enable = await this.question(`Enable ${providerConfig.name}? (Y/n): `);
+        providerConfig.enabled = enable.toLowerCase() !== 'n';
+
+        if (providerConfig.enabled) {
+            const apiKey = await this.question('Enter API key (leave empty for environment variable): ');
+            providerConfig.api_key = apiKey;
+
+            if (providerConfig.models.length > 1) {
+                console.log('Available models:');
+                providerConfig.models.forEach((model, i) => {
+                    console.log(`  ${i + 1}. ${model}`);
+                });
+
+                const modelChoice = await this.question('Select model (number or name): ');
+                providerConfig.default_model = providerConfig.models[modelChoice - 1] || modelChoice;
+            }
+        }
+    }
+
+    async interactiveSetup() {
+        console.log('🤖 Claude-All Configuration Setup');
+        console.log('==================================');
+
+        let config = this.loadConfig();
+
+        for (const [key, provider] of Object.entries(config.providers)) {
+            await this.setupProvider(key, provider);
+        }
+
+        // Set default provider
+        const enabledProviders = Object.entries(config.providers)
+            .filter(([_, p]) => p.enabled)
+            .map(([k, _]) => k);
+
+        if (enabledProviders.length > 0) {
+            console.log('\nAvailable providers:');
+            enabledProviders.forEach((p, i) => {
+                console.log(`  ${i + 1}. ${config.providers[p].name}`);
+            });
+
+            const defaultChoice = await this.question('Select default provider (number): ');
+            config.default_provider = enabledProviders[defaultChoice - 1];
+        }
+
+        // UI settings
+        console.log('\n🎨 UI Configuration');
+        const theme = await this.question('Theme (default/dark/light): ') || 'default';
+        config.ui.theme = theme;
+
+        const autoSave = await this.question('Enable auto-save? (Y/n): ');
+        config.ui.auto_save = autoSave.toLowerCase() !== 'n';
+
+        // Save configuration
+        fs.writeFileSync(this.configFile, JSON.stringify(config, null, 2));
+
+        console.log('\n✅ Configuration saved!');
+        console.log(`📁 Location: ${this.configFile}`);
+    }
+
+    showCurrentConfig() {
+        const config = this.loadConfig();
+
+        console.log('⚙️  Current Configuration');
+        console.log('========================');
+        console.log(`Version: ${config.version}`);
+        console.log(`Default Provider: ${config.default_provider}`);
+        console.log('');
+
+        console.log('🔌 Providers:');
+        for (const [key, provider] of Object.entries(config.providers)) {
+            const status = provider.enabled ? '✅' : '❌';
+            const keyStatus = provider.api_key ? '🔑' : '❌';
+            console.log(`  ${status} ${keyStatus} ${provider.name}`);
+            if (provider.default_model) {
+                console.log(`     Default: ${provider.default_model}`);
+            }
+        }
+
+        console.log('\n🎨 UI Settings:');
+        console.log(`  Theme: ${config.ui.theme}`);
+        console.log(`  Auto-save: ${config.ui.auto_save ? 'Enabled' : 'Disabled'}`);
+    }
+
+    async run() {
+        const mode = process.argv[2] || 'interactive';
+
+        if (mode === 'show') {
+            this.showCurrentConfig();
+        } else if (mode === 'interactive') {
+            await this.interactiveSetup();
+        } else {
+            console.log('Usage: npm run config [show|interactive]');
+            console.log('  show       - Show current configuration');
+            console.log('  interactive - Interactive setup wizard');
+        }
+    }
+}
+
+if (require.main === module) {
+    const config = new ConfigManager();
+    config.run().finally(() => {
+        config.rl.close();
+    });
+}
+
+module.exports = ConfigManager;

package/utils/custom-claude-config.sh

@@ -0,0 +1,89 @@
+#!/usr/bin/env bash
+
+# Custom Claude Configuration Script
+# Add custom permissions and features to Claude
+
+echo "🔧 Configuring Custom Claude Features..."
+
+CLAUDE_DIR="$HOME/.claude"
+SETTINGS_FILE="$CLAUDE_DIR/settings.json"
+
+# Backup original settings
+cp "$SETTINGS_FILE" "$SETTINGS_FILE.backup.$(date +%Y%m%d)"
+
+# Add custom permissions for enhanced functionality
+cat << 'EOF' > /tmp/custom_permissions.json
+{
+  "permissions": {
+    "allow": [
+      "Bash(*/node_modules/.bin/*)",
+      "Bash(*/dist/*)",
+      "Bash(python3 -m venv*)",
+      "Bash(docker compose*)",
+      "Bash(kubectl*)",
+      "Bash(helm*)",
+      "Bash(terraform*)",
+      "Bash(aws*)",
+      "Bash(gcloud*)",
+      "Bash(az*)",
+      "WebFetch(domain:*api.*)",
+      "WebFetch(domain:*docs.*)",
+      "WebFetch(domain:*raw.githubusercontent.com)",
+      "Bash(jest*)",
+      "Bash(python3 -m pytest*)",
+      "Bash(python3 -m pip install*)",
+      "Bash(yarn*)",
+      "Bash(pnpm*)",
+      "Bash(npx --yes*)",
+      "Bash(cargo*)",
+      "Bash(rustc*)"
+    ]
+  },
+  "env": {
+    "CLAUDE_CONTEXT_SIZE": "200000",
+    "CLAUDE_TEMPERATURE": "0.7",
+    "CLAUDE_MAX_TOKENS": "8192",
+    "CLAUDE_ENABLE_TOOLS": "true"
+  },
+  "features": {
+    "enhanced_file_history": true,
+    "project_context": true,
+    "auto_save_session": true,
+    "debug_mode": false,
+    "custom_templates": true
+  }
+}
+EOF
+
+# Merge with existing settings
+node -e "
+const fs = require('fs');
+const settings = JSON.parse(fs.readFileSync('$SETTINGS_FILE', 'utf8'));
+const custom = JSON.parse(fs.readFileSync('/tmp/custom_permissions.json', 'utf8'));
+
+// Merge permissions
+settings.permissions.allow = [...new Set([...settings.permissions.allow, ...custom.permissions.allow])];
+
+// Add or update env
+settings.env = {...settings.env, ...custom.env};
+
+// Add features
+settings.features = {...settings.features, ...custom.features};
+
+fs.writeFileSync('$SETTINGS_FILE', JSON.stringify(settings, null, 2));
+console.log('Settings updated successfully!');
+"
+
+# Clean up
+rm -f /tmp/custom_permissions.json
+
+echo "✅ Custom Claude configuration updated!"
+echo ""
+echo "📋 Added Features:"
+echo "  • Extended CLI tool permissions (npm, yarn, pnpm, cargo, etc.)"
+echo "  • Cloud provider CLI support (aws, gcloud, az)"
+echo "  • Enhanced API fetching capabilities"
+echo "  • Testing framework support (jest, pytest)"
+echo "  • Docker/Kubernetes support"
+echo "  • Custom environment variables"
+echo "  • Feature flags for enhanced functionality"

package/utils/custom-claude-hooks.md

@@ -0,0 +1,129 @@
+# Custom Claude Hooks Guide
+
+## Available Hook Events
+
+### 1. SessionStart Hook
+Already implemented for Superpowers. Location: `~/.claude/hooks/session-start.sh`
+
+### 2. PreToolUse Hook
+Triggered before any tool is used.
+
+**Example: `~/.claude/hooks/pre-tool-use.sh`**
+```bash
+#!/bin/bash
+# Log all tool usage
+echo "$(date): Using tool $1 with args: $2" >> ~/.claude/tool-usage.log
+```
+
+### 3. PostToolUse Hook
+Triggered after tool execution.
+
+**Example: `~/.claude/hooks/post-tool-use.sh`**
+```bash
+#!/bin/bash
+# Auto-commit changes after file operations
+if [[ "$1" == "Write" || "$1" == "Edit" ]]; then
+    git add -A 2>/dev/null || true
+fi
+```
+
+### 4. SessionEnd Hook
+Triggered when Claude session ends.
+
+**Example: `~/.claude/hooks/session-end.sh`**
+```bash
+#!/bin/bash
+# Clean up temporary files
+rm -rf /tmp/claude-* 2>/dev/null || true
+# Save session summary
+echo "Session ended at $(date)" >> ~/.claude/session-history.log
+```
+
+### 5. UserPromptSubmit Hook
+Triggered before processing user input.
+
+**Example: `~/.claude/hooks/user-prompt-submit.sh`**
+```bash
+#!/bin/bash
+# Auto-correct common typos
+echo "$1" | sed 's/claude-all/claude/g'
+```
+
+### 6. Stop Hook
+Triggered on graceful shutdown.
+
+**Example: `~/.claude/hooks/stop.sh`**
+```bash
+#!/bin/bash
+# Backup important files
+cp ~/.claude/history.jsonl ~/.claude/backups/history-$(date +%Y%m%d).jsonl
+```
+
+## Installing Custom Hooks
+
+1. Create hook script in `~/.claude/hooks/`
+2. Make it executable: `chmod +x hook-name.sh`
+3. Update hooks.json:
+
+```json
+{
+  "hooks": {
+    "SessionStart": "session-start.sh",
+    "PreToolUse": "pre-tool-use.sh",
+    "PostToolUse": "post-tool-use.sh",
+    "SessionEnd": "session-end.sh",
+    "UserPromptSubmit": "user-prompt-submit.sh",
+    "Stop": "stop.sh"
+  }
+}
+```
+
+## Hook Return Format
+
+Hooks should return JSON output:
+
+```json
+{
+  "hookSpecificOutput": {
+    "hookEventName": "EventName",
+    "additionalContext": "Additional context for Claude",
+    "modifications": {
+      "settings": {...},
+      "environment": {...}
+    }
+  }
+}
+```
+
+## Advanced Hook Ideas
+
+### Auto-Save Hook
+```bash
+# Auto-save work every 10 minutes
+#!/bin/bash
+if [[ $(($(date +%s) % 600)) -lt 5 ]]; then
+    echo "Auto-saving session..."
+    # Add save logic here
+fi
+```
+
+### Context Enhancement Hook
+```bash
+# Add project context
+if [[ -f "project.md" ]]; then
+    echo -e "\n<project-context>\n$(cat project.md)\n</project-context>"
+fi
+```
+
+### Performance Monitoring Hook
+```bash
+# Log performance metrics
+echo "$(date),$1,$(($(date +%s%N)/1000000))" >> ~/.claude/performance.log
+```
+
+## Security Notes
+
+- Hooks run with your user permissions
+- Validate all hook inputs
+- Avoid executing arbitrary commands from hook input
+- Keep hooks simple and focused

package/utils/custom-claude-lib.js

@@ -0,0 +1,222 @@
+// Custom Claude Library Functions
+// Save to ~/.claude/lib/custom-utils.js
+
+// Utility functions for Claude to use
+module.exports = {
+  // File operations
+  async countLines(filePath) {
+    const fs = require('fs').promises;
+    try {
+      const content = await fs.readFile(filePath, 'utf8');
+      return content.split('\n').length;
+    } catch (error) {
+      return 0;
+    }
+  },
+
+  // Project analysis
+  async analyzeProject(directory) {
+    const fs = require('fs').promises;
+    const path = require('path');
+
+    const stats = {
+      files: 0,
+      directories: 0,
+      extensions: {},
+      totalLines: 0
+    };
+
+    async function walk(dir) {
+      const items = await fs.readdir(dir);
+      for (const item of items) {
+        const fullPath = path.join(dir, item);
+        const stat = await fs.stat(fullPath);
+
+        if (stat.isDirectory()) {
+          stats.directories++;
+          await walk(fullPath);
+        } else {
+          stats.files++;
+          const ext = path.extname(item).toLowerCase();
+          stats.extensions[ext] = (stats.extensions[ext] || 0) + 1;
+
+          // Count lines for text files
+          const textExtensions = ['.js', '.ts', '.py', '.java', '.cpp', '.c', '.md', '.txt', '.json', '.yaml', '.yml'];
+          if (textExtensions.includes(ext)) {
+            stats.totalLines += await this.countLines(fullPath);
+          }
+        }
+      }
+    }
+
+    await walk(directory);
+    return stats;
+  },
+
+  // Generate project summary
+  generateProjectSummary(stats) {
+    const sortedExts = Object.entries(stats.extensions)
+      .sort((a, b) => b[1] - a[1])
+      .slice(0, 5)
+      .map(([ext, count]) => `${ext} (${count})`)
+      .join(', ');
+
+    return `
+Project Analysis:
+- Files: ${stats.files}
+- Directories: ${stats.directories}
+- Total Lines: ${stats.totalLines}
+- Top Extensions: ${sortedExts}
+    `.trim();
+  },
+
+  // Template generators
+  generateReadme(projectName, type = 'general') {
+    const templates = {
+      api: `# ${projectName} API
+
+## Installation
+\`\`\`bash
+npm install
+\`\`\`
+
+## Usage
+\`\`\`javascript
+const API = require('${projectName}');
+const api = new API();
+\`\`\`
+
+## Endpoints
+- GET /api/items
+- POST /api/items
+- PUT /api/items/:id
+- DELETE /api/items/:id
+`,
+
+      cli: `# ${projectName} CLI Tool
+
+## Installation
+\`\`\`bash
+npm install -g ${projectName}
+\`\`\`
+
+## Usage
+\`\`\`bash
+${projectName} --help
+${projectName} --version
+\`\`\`
+`,
+
+      general: `# ${projectName}
+
+## Description
+TODO: Add project description
+
+## Installation
+\`\`\`bash
+npm install
+\`\`\`
+
+## Usage
+TODO: Add usage instructions
+`
+    };
+
+    return templates[type] || templates.general;
+  },
+
+  // Git helpers
+  async getGitStats() {
+    const { exec } = require('child_process');
+    const { promisify } = require('util');
+    const execAsync = promisify(exec);
+
+    try {
+      const [hash, branch, commits] = await Promise.all([
+        execAsync('git rev-parse HEAD').then(r => r.stdout.trim()),
+        execAsync('git rev-parse --abbrev-ref HEAD').then(r => r.stdout.trim()),
+        execAsync('git rev-list --count HEAD').then(r => parseInt(r.stdout.trim()))
+      ]);
+
+      return { hash: hash.substring(0, 7), branch, commits };
+    } catch {
+      return null;
+    }
+  },
+
+  // Environment helpers
+  detectEnvironment() {
+    const env = {
+      node: typeof process !== 'undefined',
+      browser: typeof window !== 'undefined',
+      deno: typeof Deno !== 'undefined'
+    };
+
+    if (env.node) {
+      env.packageManager = fs.existsSync('yarn.lock') ? 'yarn' :
+                          fs.existsSync('pnpm-lock.yaml') ? 'pnpm' : 'npm';
+    }
+
+    return env;
+  },
+
+  // Code quality checks
+  async checkCodeQuality(directory) {
+    const fs = require('fs').promises;
+    const issues = [];
+
+    async function checkFile(filePath) {
+      const content = await fs.readFile(filePath, 'utf8');
+
+      // Check for console.log statements
+      if (content.includes('console.log')) {
+        issues.push(`${filePath}: Contains console.log statements`);
+      }
+
+      // Check for TODO comments
+      if (content.includes('TODO:') || content.includes('FIXME:')) {
+        issues.push(`${filePath}: Contains TODO/FIXME comments`);
+      }
+
+      // Check for long lines (> 120 characters)
+      const lines = content.split('\n');
+      lines.forEach((line, i) => {
+        if (line.length > 120) {
+          issues.push(`${filePath}:${i + 1}: Line too long (${line.length} chars)`);
+        }
+      });
+    }
+
+    // Scan JavaScript/TypeScript files
+    const jsFiles = await this.findFiles(directory, ['.js', '.ts']);
+    await Promise.all(jsFiles.map(checkFile));
+
+    return issues;
+  },
+
+  // File system helpers
+  async findFiles(directory, extensions) {
+    const fs = require('fs').promises;
+    const path = require('path');
+    const results = [];
+
+    async function walk(dir) {
+      const items = await fs.readdir(dir);
+      for (const item of items) {
+        if (item.startsWith('.')) continue;
+
+        const fullPath = path.join(dir, item);
+        const stat = await fs.stat(fullPath);
+
+        if (stat.isDirectory()) {
+          await walk(fullPath);
+        } else if (extensions.includes(path.extname(item))) {
+          results.push(fullPath);
+        }
+      }
+    }
+
+    await walk(directory);
+    return results;
+  }
+};