@wundr.io/cli 1.0.12 → 1.0.14

package/dist/utils/claude-config-installer.js

@@ -0,0 +1,678 @@
+"use strict";
+/**
+ * Claude Code Configuration Installer
+ * Handles installation of CLAUDE.md, hooks, conventions, and agent templates
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClaudeConfigInstaller = void 0;
+const tslib_1 = require("tslib");
+const fs_1 = require("fs");
+const fs = tslib_1.__importStar(require("fs/promises"));
+const path = tslib_1.__importStar(require("path"));
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const ora_1 = tslib_1.__importDefault(require("ora"));
+const backup_rollback_manager_1 = require("./backup-rollback-manager");
+const logger_1 = require("./logger");
+class ClaudeConfigInstaller {
+    claudeDir;
+    sourceDir;
+    backupManager;
+    homeDir;
+    constructor(options = {}) {
+        this.homeDir = process.env.HOME || process.env.USERPROFILE || '';
+        this.claudeDir = options.claudeDir || path.join(this.homeDir, '.claude');
+        this.sourceDir = options.sourceDir || process.cwd();
+        this.backupManager = new backup_rollback_manager_1.BackupRollbackManager();
+    }
+    /**
+     * Initialize installer
+     */
+    async initialize() {
+        await this.backupManager.initialize();
+        // Create Claude directory structure
+        await this.createDirectoryStructure();
+    }
+    /**
+     * Install all Claude Code configurations
+     */
+    async install(options = {}) {
+        const { dryRun = false, skipBackup = false, overwrite = false, verbose = false, } = options;
+        const result = {
+            success: false,
+            installed: [],
+            skipped: [],
+            errors: [],
+        };
+        try {
+            console.log(chalk_1.default.cyan('\n🔧 Installing Claude Code Configuration\n'));
+            // Create backup of existing configs
+            if (!skipBackup && !dryRun) {
+                const existingFiles = await this.getExistingConfigFiles();
+                if (existingFiles.length > 0) {
+                    const spinner = (0, ora_1.default)('Creating backup of existing configurations...').start();
+                    const backup = await this.backupManager.createBackup(existingFiles, 'Pre-installation backup');
+                    result.backupId = backup.backupId;
+                    spinner.succeed(`Backup created: ${backup.backupId}`);
+                }
+            }
+            // Install CLAUDE.md
+            await this.installClaudeMd(result, { dryRun, overwrite, verbose });
+            // Install hooks
+            await this.installHooks(result, { dryRun, overwrite, verbose });
+            // Install conventions
+            await this.installConventions(result, { dryRun, overwrite, verbose });
+            // Install agent templates
+            await this.installAgentTemplates(result, { dryRun, overwrite, verbose });
+            // Install git-worktree workflows
+            await this.installGitWorktreeWorkflows(result, {
+                dryRun,
+                overwrite,
+                verbose,
+            });
+            // Install validation scripts
+            await this.installValidationScripts(result, {
+                dryRun,
+                overwrite,
+                verbose,
+            });
+            result.success = result.errors.length === 0;
+            // Display summary
+            this.displayInstallSummary(result, dryRun);
+            return result;
+        }
+        catch (error) {
+            logger_1.logger.error('Installation failed', error);
+            result.errors.push({
+                file: 'general',
+                error: error instanceof Error ? error.message : String(error),
+            });
+            return result;
+        }
+    }
+    /**
+     * Install enhanced CLAUDE.md to ~/.claude/
+     */
+    async installClaudeMd(result, options) {
+        const spinner = (0, ora_1.default)('Installing CLAUDE.md...').start();
+        try {
+            const sourcePath = path.join(this.sourceDir, 'CLAUDE.md');
+            const targetPath = path.join(this.claudeDir, 'CLAUDE.md');
+            if (!(0, fs_1.existsSync)(sourcePath)) {
+                spinner.warn('CLAUDE.md not found in source directory');
+                result.skipped.push('CLAUDE.md');
+                return;
+            }
+            if ((0, fs_1.existsSync)(targetPath) && !options.overwrite) {
+                if (options.verbose) {
+                    spinner.info('CLAUDE.md already exists (use --overwrite to replace)');
+                }
+                result.skipped.push('CLAUDE.md');
+                return;
+            }
+            if (options.dryRun) {
+                spinner.info('Would install CLAUDE.md');
+                result.installed.push('CLAUDE.md (dry-run)');
+                return;
+            }
+            await fs.copyFile(sourcePath, targetPath);
+            spinner.succeed('CLAUDE.md installed');
+            result.installed.push('CLAUDE.md');
+            logger_1.logger.info('CLAUDE.md installed', { target: targetPath });
+        }
+        catch (error) {
+            spinner.fail('Failed to install CLAUDE.md');
+            result.errors.push({
+                file: 'CLAUDE.md',
+                error: error instanceof Error ? error.message : String(error),
+            });
+            logger_1.logger.error('CLAUDE.md installation failed', error);
+        }
+    }
+    /**
+     * Install hooks configuration
+     */
+    async installHooks(result, options) {
+        const spinner = (0, ora_1.default)('Installing hooks...').start();
+        try {
+            const hooksDir = path.join(this.claudeDir, 'hooks');
+            await fs.mkdir(hooksDir, { recursive: true });
+            const hooks = this.generateHooksConfig();
+            for (const [hookName, hookContent] of Object.entries(hooks)) {
+                const hookPath = path.join(hooksDir, hookName);
+                if ((0, fs_1.existsSync)(hookPath) && !options.overwrite) {
+                    result.skipped.push(`hooks/${hookName}`);
+                    continue;
+                }
+                if (options.dryRun) {
+                    result.installed.push(`hooks/${hookName} (dry-run)`);
+                    continue;
+                }
+                await fs.writeFile(hookPath, hookContent);
+                await fs.chmod(hookPath, 0o755); // Make executable
+                result.installed.push(`hooks/${hookName}`);
+            }
+            spinner.succeed(`Hooks installed (${Object.keys(hooks).length} files)`);
+            logger_1.logger.info('Hooks installed', { count: Object.keys(hooks).length });
+        }
+        catch (error) {
+            spinner.fail('Failed to install hooks');
+            result.errors.push({
+                file: 'hooks',
+                error: error instanceof Error ? error.message : String(error),
+            });
+            logger_1.logger.error('Hooks installation failed', error);
+        }
+    }
+    /**
+     * Install conventions
+     */
+    async installConventions(result, options) {
+        const spinner = (0, ora_1.default)('Installing conventions...').start();
+        try {
+            const conventionsPath = path.join(this.claudeDir, 'conventions.json');
+            const conventions = this.generateConventions();
+            if ((0, fs_1.existsSync)(conventionsPath) && !options.overwrite) {
+                spinner.info('Conventions already exist');
+                result.skipped.push('conventions.json');
+                return;
+            }
+            if (options.dryRun) {
+                spinner.info('Would install conventions');
+                result.installed.push('conventions.json (dry-run)');
+                return;
+            }
+            await fs.writeFile(conventionsPath, JSON.stringify(conventions, null, 2));
+            spinner.succeed('Conventions installed');
+            result.installed.push('conventions.json');
+            logger_1.logger.info('Conventions installed', { path: conventionsPath });
+        }
+        catch (error) {
+            spinner.fail('Failed to install conventions');
+            result.errors.push({
+                file: 'conventions.json',
+                error: error instanceof Error ? error.message : String(error),
+            });
+            logger_1.logger.error('Conventions installation failed', error);
+        }
+    }
+    /**
+     * Install agent templates
+     */
+    async installAgentTemplates(result, options) {
+        const spinner = (0, ora_1.default)('Installing agent templates...').start();
+        try {
+            const agentsDir = path.join(this.claudeDir, 'agents');
+            await fs.mkdir(agentsDir, { recursive: true });
+            const templates = this.generateAgentTemplates();
+            for (const [agentName, agentConfig] of Object.entries(templates)) {
+                // Generate .md files with proper YAML frontmatter (not .json)
+                const agentPath = path.join(agentsDir, `${agentName}.md`);
+                if ((0, fs_1.existsSync)(agentPath) && !options.overwrite) {
+                    result.skipped.push(`agents/${agentName}.md`);
+                    continue;
+                }
+                if (options.dryRun) {
+                    result.installed.push(`agents/${agentName}.md (dry-run)`);
+                    continue;
+                }
+                // Generate markdown with YAML frontmatter
+                const mdContent = this.generateAgentMarkdownContent(agentName, agentConfig);
+                await fs.writeFile(agentPath, mdContent);
+                result.installed.push(`agents/${agentName}.md`);
+            }
+            spinner.succeed(`Agent templates installed (${Object.keys(templates).length} templates)`);
+            logger_1.logger.info('Agent templates installed', {
+                count: Object.keys(templates).length,
+            });
+        }
+        catch (error) {
+            spinner.fail('Failed to install agent templates');
+            result.errors.push({
+                file: 'agent-templates',
+                error: error instanceof Error ? error.message : String(error),
+            });
+            logger_1.logger.error('Agent templates installation failed', error);
+        }
+    }
+    /**
+     * Generate markdown content with proper YAML frontmatter for agent files
+     */
+    generateAgentMarkdownContent(agentName, config) {
+        const firstResponsibility = config.responsibilities[0] ?? 'software development';
+        const description = `${config.name} specialist for ${firstResponsibility.toLowerCase()}.`;
+        const toolsList = 'Read, Write, Edit, Bash, Glob, Grep';
+        const useFor = config.responsibilities.slice(0, 2).join(', ').toLowerCase() ||
+            'development tasks';
+        return `---
+name: ${agentName}
+description: >
+  ${description}
+  Use for ${useFor}.
+tools: ${toolsList}
+model: sonnet
+---
+
+# ${config.name}
+
+## Role
+${config.role}
+
+## Responsibilities
+${config.responsibilities.map(r => `- ${r}`).join('\n')}
+
+## Tools & Technologies
+${config.tools.map(t => `- ${t}`).join('\n')}
+
+## Patterns
+${config.patterns.map(p => `- ${p}`).join('\n')}
+`;
+    }
+    /**
+     * Install git-worktree workflows
+     */
+    async installGitWorktreeWorkflows(result, options) {
+        const spinner = (0, ora_1.default)('Installing git-worktree workflows...').start();
+        try {
+            const workflowsDir = path.join(this.claudeDir, 'workflows');
+            await fs.mkdir(workflowsDir, { recursive: true });
+            const workflows = this.generateGitWorktreeWorkflows();
+            for (const [workflowName, workflowContent] of Object.entries(workflows)) {
+                const workflowPath = path.join(workflowsDir, `${workflowName}.json`);
+                if ((0, fs_1.existsSync)(workflowPath) && !options.overwrite) {
+                    result.skipped.push(`workflows/${workflowName}.json`);
+                    continue;
+                }
+                if (options.dryRun) {
+                    result.installed.push(`workflows/${workflowName}.json (dry-run)`);
+                    continue;
+                }
+                await fs.writeFile(workflowPath, JSON.stringify(workflowContent, null, 2));
+                result.installed.push(`workflows/${workflowName}.json`);
+            }
+            spinner.succeed(`Git-worktree workflows installed (${Object.keys(workflows).length} workflows)`);
+            logger_1.logger.info('Git-worktree workflows installed', {
+                count: Object.keys(workflows).length,
+            });
+        }
+        catch (error) {
+            spinner.fail('Failed to install git-worktree workflows');
+            result.errors.push({
+                file: 'git-worktree-workflows',
+                error: error instanceof Error ? error.message : String(error),
+            });
+            logger_1.logger.error('Git-worktree workflows installation failed', error);
+        }
+    }
+    /**
+     * Install validation scripts
+     */
+    async installValidationScripts(result, options) {
+        const spinner = (0, ora_1.default)('Installing validation scripts...').start();
+        try {
+            const scriptsDir = path.join(this.claudeDir, 'scripts');
+            await fs.mkdir(scriptsDir, { recursive: true });
+            const scripts = this.generateValidationScripts();
+            for (const [scriptName, scriptContent] of Object.entries(scripts)) {
+                const scriptPath = path.join(scriptsDir, scriptName);
+                if ((0, fs_1.existsSync)(scriptPath) && !options.overwrite) {
+                    result.skipped.push(`scripts/${scriptName}`);
+                    continue;
+                }
+                if (options.dryRun) {
+                    result.installed.push(`scripts/${scriptName} (dry-run)`);
+                    continue;
+                }
+                await fs.writeFile(scriptPath, scriptContent);
+                await fs.chmod(scriptPath, 0o755); // Make executable
+                result.installed.push(`scripts/${scriptName}`);
+            }
+            spinner.succeed(`Validation scripts installed (${Object.keys(scripts).length} scripts)`);
+            logger_1.logger.info('Validation scripts installed', {
+                count: Object.keys(scripts).length,
+            });
+        }
+        catch (error) {
+            spinner.fail('Failed to install validation scripts');
+            result.errors.push({
+                file: 'validation-scripts',
+                error: error instanceof Error ? error.message : String(error),
+            });
+            logger_1.logger.error('Validation scripts installation failed', error);
+        }
+    }
+    /**
+     * Create directory structure
+     */
+    async createDirectoryStructure() {
+        const dirs = [
+            this.claudeDir,
+            path.join(this.claudeDir, 'hooks'),
+            path.join(this.claudeDir, 'agents'),
+            path.join(this.claudeDir, 'workflows'),
+            path.join(this.claudeDir, 'scripts'),
+            path.join(this.claudeDir, 'templates'),
+        ];
+        for (const dir of dirs) {
+            await fs.mkdir(dir, { recursive: true });
+        }
+    }
+    /**
+     * Get existing config files for backup
+     */
+    async getExistingConfigFiles() {
+        const files = [];
+        const checkFiles = [
+            path.join(this.claudeDir, 'CLAUDE.md'),
+            path.join(this.claudeDir, 'conventions.json'),
+        ];
+        for (const file of checkFiles) {
+            if ((0, fs_1.existsSync)(file)) {
+                files.push(file);
+            }
+        }
+        return files;
+    }
+    /**
+     * Generate hooks configuration files
+     */
+    generateHooksConfig() {
+        return {
+            'pre-commit': `#!/bin/bash
+# Claude Code pre-commit hook
+# Auto-generated by Wundr computer-setup
+
+echo "🔍 Running pre-commit checks..."
+
+# Run linting
+if command -v npm &> /dev/null; then
+  npm run lint --if-present || true
+fi
+
+# Run type checking
+if command -v npm &> /dev/null; then
+  npm run typecheck --if-present || true
+fi
+
+echo "✅ Pre-commit checks completed"
+`,
+            'post-checkout': `#!/bin/bash
+# Claude Code post-checkout hook
+# Auto-generated by Wundr computer-setup
+
+echo "🔄 Post-checkout: Installing dependencies..."
+
+# Install dependencies if package.json changed
+if command -v npm &> /dev/null; then
+  npm install --if-present || true
+fi
+
+echo "✅ Post-checkout completed"
+`,
+        };
+    }
+    /**
+     * Generate conventions configuration
+     */
+    generateConventions() {
+        return {
+            fileNaming: {
+                components: 'PascalCase',
+                utilities: 'camelCase',
+                constants: 'UPPER_SNAKE_CASE',
+                types: 'PascalCase',
+            },
+            codeStyle: {
+                indentation: 2,
+                quotes: 'single',
+                semicolons: true,
+                trailingComma: 'es5',
+            },
+            imports: {
+                order: ['external', 'internal', 'parent', 'sibling', 'index'],
+                grouping: true,
+            },
+            testing: {
+                framework: 'jest',
+                coverage: {
+                    statements: 80,
+                    branches: 80,
+                    functions: 80,
+                    lines: 80,
+                },
+            },
+            git: {
+                commitMessage: 'conventional-commits',
+                branchNaming: 'feature/*, fix/*, chore/*',
+            },
+        };
+    }
+    /**
+     * Generate agent templates
+     */
+    generateAgentTemplates() {
+        return {
+            'backend-developer': {
+                name: 'Backend Developer',
+                role: 'backend-dev',
+                responsibilities: [
+                    'Design RESTful and GraphQL APIs',
+                    'Implement database models and queries',
+                    'Create authentication and authorization',
+                    'Write comprehensive API documentation',
+                ],
+                tools: ['node', 'typescript', 'postgresql', 'redis'],
+                patterns: [
+                    'Controller-Service-Repository',
+                    'DTO pattern',
+                    'Middleware pattern',
+                ],
+            },
+            'frontend-developer': {
+                name: 'Frontend Developer',
+                role: 'frontend-dev',
+                responsibilities: [
+                    'Build responsive user interfaces',
+                    'Implement state management',
+                    'Create reusable components',
+                    'Optimize performance',
+                ],
+                tools: ['react', 'typescript', 'tailwind', 'vite'],
+                patterns: ['Component composition', 'Custom hooks', 'Context API'],
+            },
+            'fullstack-developer': {
+                name: 'Fullstack Developer',
+                role: 'fullstack-dev',
+                responsibilities: [
+                    'Develop end-to-end features',
+                    'Integrate frontend and backend',
+                    'Manage database schemas',
+                    'Deploy applications',
+                ],
+                tools: ['node', 'react', 'typescript', 'docker'],
+                patterns: ['Full-stack architecture', 'API integration', 'CI/CD'],
+            },
+        };
+    }
+    /**
+     * Generate git-worktree workflows
+     */
+    generateGitWorktreeWorkflows() {
+        return {
+            'feature-development': {
+                name: 'Feature Development Workflow',
+                description: 'Workflow for developing new features in isolation',
+                steps: [
+                    {
+                        name: 'Create worktree',
+                        command: 'git worktree add ../feature-name feature/name',
+                    },
+                    {
+                        name: 'Setup environment',
+                        command: 'cd ../feature-name && npm install',
+                    },
+                    {
+                        name: 'Run tests',
+                        command: 'npm test',
+                    },
+                    {
+                        name: 'Commit changes',
+                        command: 'git add . && git commit -m "feat: description"',
+                    },
+                ],
+            },
+            'bug-fix': {
+                name: 'Bug Fix Workflow',
+                description: 'Workflow for fixing bugs without affecting main development',
+                steps: [
+                    {
+                        name: 'Create worktree',
+                        command: 'git worktree add ../fix-bug fix/bug-name',
+                    },
+                    {
+                        name: 'Reproduce bug',
+                        command: 'npm test -- bug.test.ts',
+                    },
+                    {
+                        name: 'Fix and verify',
+                        command: 'npm test',
+                    },
+                    {
+                        name: 'Commit fix',
+                        command: 'git add . && git commit -m "fix: description"',
+                    },
+                ],
+            },
+        };
+    }
+    /**
+     * Generate validation scripts
+     */
+    generateValidationScripts() {
+        return {
+            'validate-setup.sh': `#!/bin/bash
+# Validate Claude Code setup
+# Auto-generated by Wundr computer-setup
+
+echo "🔍 Validating Claude Code setup..."
+
+# Check for required files
+FILES=(
+  "$HOME/.claude/CLAUDE.md"
+  "$HOME/.claude/conventions.json"
+)
+
+MISSING=0
+for file in "\${FILES[@]}"; do
+  if [ ! -f "$file" ]; then
+    echo "❌ Missing: $file"
+    MISSING=$((MISSING + 1))
+  else
+    echo "✅ Found: $file"
+  fi
+done
+
+# Check for required directories
+DIRS=(
+  "$HOME/.claude/hooks"
+  "$HOME/.claude/agents"
+  "$HOME/.claude/workflows"
+)
+
+for dir in "\${DIRS[@]}"; do
+  if [ ! -d "$dir" ]; then
+    echo "❌ Missing directory: $dir"
+    MISSING=$((MISSING + 1))
+  else
+    echo "✅ Found directory: $dir"
+  fi
+done
+
+if [ $MISSING -eq 0 ]; then
+  echo "✅ All validations passed!"
+  exit 0
+else
+  echo "❌ $MISSING validation(s) failed"
+  exit 1
+fi
+`,
+            'check-config.sh': `#!/bin/bash
+# Check Claude Code configuration
+# Auto-generated by Wundr computer-setup
+
+echo "🔧 Checking Claude Code configuration..."
+
+# Check Claude CLI
+if command -v claude &> /dev/null; then
+  echo "✅ Claude CLI: $(claude --version)"
+else
+  echo "⚠️  Claude CLI not found"
+fi
+
+# Check Node.js
+if command -v node &> /dev/null; then
+  echo "✅ Node.js: $(node --version)"
+else
+  echo "❌ Node.js not found"
+fi
+
+# Check Git
+if command -v git &> /dev/null; then
+  echo "✅ Git: $(git --version)"
+else
+  echo "❌ Git not found"
+fi
+
+echo "✅ Configuration check complete"
+`,
+        };
+    }
+    /**
+     * Display installation summary
+     */
+    displayInstallSummary(result, dryRun) {
+        console.log(chalk_1.default.cyan('\n📊 Installation Summary\n'));
+        if (dryRun) {
+            console.log(chalk_1.default.yellow('🔍 DRY RUN MODE - No files were modified\n'));
+        }
+        if (result.backupId) {
+            console.log(chalk_1.default.gray(`Backup ID: ${result.backupId}\n`));
+        }
+        if (result.installed.length > 0) {
+            console.log(chalk_1.default.green(`✅ Installed (${result.installed.length}):`));
+            result.installed.forEach(file => {
+                console.log(chalk_1.default.white(`  • ${file}`));
+            });
+            console.log();
+        }
+        if (result.skipped.length > 0) {
+            console.log(chalk_1.default.yellow(`⏭️  Skipped (${result.skipped.length}):`));
+            result.skipped.forEach(file => {
+                console.log(chalk_1.default.gray(`  • ${file}`));
+            });
+            console.log();
+        }
+        if (result.errors.length > 0) {
+            console.log(chalk_1.default.red(`❌ Errors (${result.errors.length}):`));
+            result.errors.forEach(error => {
+                console.log(chalk_1.default.red(`  • ${error.file}: ${error.error}`));
+            });
+            console.log();
+        }
+        if (result.success) {
+            console.log(chalk_1.default.green('✅ Installation completed successfully!\n'));
+            console.log(chalk_1.default.cyan('Next steps:'));
+            console.log(chalk_1.default.white('  1. Review installed configurations'));
+            console.log(chalk_1.default.white('  2. Run validation: ~/.claude/scripts/validate-setup.sh'));
+            console.log(chalk_1.default.white('  3. Customize agent templates as needed'));
+        }
+        else {
+            console.log(chalk_1.default.red('❌ Installation completed with errors\n'));
+            if (result.backupId) {
+                console.log(chalk_1.default.cyan('To rollback:'));
+                console.log(chalk_1.default.white(`  wundr computer-setup rollback --backup ${result.backupId}`));
+            }
+        }
+    }
+}
+exports.ClaudeConfigInstaller = ClaudeConfigInstaller;
+//# sourceMappingURL=claude-config-installer.js.map