claude-flow-novice 2.0.3 → 2.0.4

package/dist/src/migration/migration-validator.js

@@ -0,0 +1,285 @@
+/**
+ * Migration Validator - Validates successful migration
+ */ function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+import * as fs from "fs-extra";
+import * as path from "path";
+import * as chalk from "chalk";
+import { glob } from "glob";
+export class MigrationValidator {
+    async validate(projectPath) {
+        const result = {
+            valid: true,
+            checks: [],
+            errors: [],
+            warnings: []
+        };
+        // Check file structure
+        await this.validateFileStructure(projectPath, result);
+        // Check command files
+        await this.validateCommandFiles(projectPath, result);
+        // Check configuration files
+        await this.validateConfiguration(projectPath, result);
+        // Check file integrity
+        await this.validateFileIntegrity(projectPath, result);
+        // Check functionality
+        await this.validateFunctionality(projectPath, result);
+        // Overall validation
+        result.valid = result.errors.length === 0;
+        return result;
+    }
+    async validateFileStructure(projectPath, result) {
+        const check = {
+            name: 'File Structure',
+            passed: true
+        };
+        // Check .claude directory exists
+        const claudePath = path.join(projectPath, '.claude');
+        if (!await fs.pathExists(claudePath)) {
+            check.passed = false;
+            result.errors.push('.claude directory not found');
+        }
+        // Check commands directory
+        const commandsPath = path.join(claudePath, 'commands');
+        if (!await fs.pathExists(commandsPath)) {
+            check.passed = false;
+            result.errors.push('.claude/commands directory not found');
+        }
+        // Check required files
+        for (const file of this.requiredFiles){
+            const filePath = path.join(projectPath, file);
+            if (!await fs.pathExists(filePath)) {
+                check.passed = false;
+                result.errors.push(`Required file missing: ${file}`);
+            }
+        }
+        result.checks.push(check);
+    }
+    async validateCommandFiles(projectPath, result) {
+        const check = {
+            name: 'Command Files',
+            passed: true
+        };
+        const commandsPath = path.join(projectPath, '.claude/commands');
+        if (await fs.pathExists(commandsPath)) {
+            for (const command of this.requiredCommands){
+                const commandFile = path.join(commandsPath, `${command}.md`);
+                const sparcCommandFile = path.join(commandsPath, 'sparc', `${command.replace('sparc-', '')}.md`);
+                const hasMainFile = await fs.pathExists(commandFile);
+                const hasSparcFile = await fs.pathExists(sparcCommandFile);
+                if (!hasMainFile && !hasSparcFile) {
+                    check.passed = false;
+                    result.errors.push(`Command file missing: ${command}.md`);
+                } else {
+                    // Validate file content
+                    const filePath = hasMainFile ? commandFile : sparcCommandFile;
+                    await this.validateCommandFileContent(filePath, command, result);
+                }
+            }
+        } else {
+            check.passed = false;
+            result.errors.push('Commands directory not found');
+        }
+        result.checks.push(check);
+    }
+    async validateCommandFileContent(filePath, command, result) {
+        try {
+            const content = await fs.readFile(filePath, 'utf-8');
+            // Check for minimum content requirements
+            const hasDescription = content.includes('description') || content.includes('Description');
+            const hasInstructions = content.length > 100; // Minimum content length
+            if (!hasDescription) {
+                result.warnings.push(`Command ${command} may be missing description`);
+            }
+            if (!hasInstructions) {
+                result.warnings.push(`Command ${command} may have insufficient content`);
+            }
+            // Check for optimization indicators
+            const hasOptimizedContent = content.includes('optimization') || content.includes('performance') || content.includes('efficient');
+            if (!hasOptimizedContent && command.includes('sparc')) {
+                result.warnings.push(`SPARC command ${command} may not be optimized`);
+            }
+        } catch (error) {
+            result.errors.push(`Failed to validate ${command}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    async validateConfiguration(projectPath, result) {
+        const check = {
+            name: 'Configuration Files',
+            passed: true
+        };
+        // Check CLAUDE.md
+        const claudeMdPath = path.join(projectPath, 'CLAUDE.md');
+        if (await fs.pathExists(claudeMdPath)) {
+            const content = await fs.readFile(claudeMdPath, 'utf-8');
+            // Check for SPARC configuration
+            if (!content.includes('SPARC')) {
+                result.warnings.push('CLAUDE.md may not include SPARC configuration');
+            }
+            // Check for key sections
+            const requiredSections = [
+                'Project Overview',
+                'SPARC Development',
+                'Memory Integration'
+            ];
+            for (const section of requiredSections){
+                if (!content.includes(section)) {
+                    result.warnings.push(`CLAUDE.md missing section: ${section}`);
+                }
+            }
+        } else {
+            result.warnings.push('CLAUDE.md not found');
+        }
+        // Check .roomodes
+        const roomodesPath = path.join(projectPath, '.roomodes');
+        if (await fs.pathExists(roomodesPath)) {
+            try {
+                const roomodes = await fs.readJson(roomodesPath);
+                const requiredModes = [
+                    'architect',
+                    'code',
+                    'tdd',
+                    'debug'
+                ];
+                for (const mode of requiredModes){
+                    if (!roomodes[mode]) {
+                        result.warnings.push(`Missing SPARC mode: ${mode}`);
+                    }
+                }
+            } catch (error) {
+                result.errors.push(`Invalid .roomodes file: ${error instanceof Error ? error.message : String(error)}`);
+                check.passed = false;
+            }
+        }
+        result.checks.push(check);
+    }
+    async validateFileIntegrity(projectPath, result) {
+        const check = {
+            name: 'File Integrity',
+            passed: true
+        };
+        // Check for corrupted files
+        const claudePath = path.join(projectPath, '.claude');
+        if (await fs.pathExists(claudePath)) {
+            const files = await glob('**/*.md', {
+                cwd: claudePath
+            });
+            for (const file of files){
+                try {
+                    const content = await fs.readFile(path.join(claudePath, file), 'utf-8');
+                    // Basic integrity checks
+                    if (content.length === 0) {
+                        result.errors.push(`Empty file: ${file}`);
+                        check.passed = false;
+                    }
+                    // Check for binary data in text files
+                    if (content.includes('\0')) {
+                        result.errors.push(`Corrupted text file: ${file}`);
+                        check.passed = false;
+                    }
+                } catch (error) {
+                    result.errors.push(`Cannot read file ${file}: ${error instanceof Error ? error.message : String(error)}`);
+                    check.passed = false;
+                }
+            }
+        }
+        result.checks.push(check);
+    }
+    async validateFunctionality(projectPath, result) {
+        const check = {
+            name: 'Functionality',
+            passed: true
+        };
+        // Check directory permissions
+        const claudePath = path.join(projectPath, '.claude');
+        if (await fs.pathExists(claudePath)) {
+            try {
+                // Test write permissions
+                const testFile = path.join(claudePath, '.test-write');
+                await fs.writeFile(testFile, 'test');
+                await fs.remove(testFile);
+            } catch (error) {
+                result.warnings.push('.claude directory may not be writable');
+            }
+        }
+        // Check for potential conflicts
+        const packageJsonPath = path.join(projectPath, 'package.json');
+        if (await fs.pathExists(packageJsonPath)) {
+            try {
+                const packageJson = await fs.readJson(packageJsonPath);
+                // Check for script conflicts
+                const scripts = packageJson.scripts || {};
+                const conflictingScripts = Object.keys(scripts).filter((script)=>script.startsWith('claude-flow') || script.startsWith('sparc'));
+                if (conflictingScripts.length > 0) {
+                    result.warnings.push(`Potential script conflicts: ${conflictingScripts.join(', ')}`);
+                }
+            } catch (error) {
+                result.warnings.push('Could not validate package.json');
+            }
+        }
+        result.checks.push(check);
+    }
+    printValidation(validation) {
+        console.log(chalk.bold('\n✅ Migration Validation Report'));
+        console.log(chalk.gray('─'.repeat(50)));
+        console.log(`\n${chalk.bold('Overall Status:')} ${validation.valid ? chalk.green('✓ Valid') : chalk.red('✗ Invalid')}`);
+        // Show checks
+        console.log(chalk.bold('\n📋 Validation Checks:'));
+        validation.checks.forEach((check)=>{
+            const status = check.passed ? chalk.green('✓') : chalk.red('✗');
+            console.log(`  ${status} ${check.name}`);
+            if (check.message) {
+                console.log(`     ${chalk.gray(check.message)}`);
+            }
+        });
+        // Show errors
+        if (validation.errors.length > 0) {
+            console.log(chalk.bold('\n❌ Errors:'));
+            validation.errors.forEach((error)=>{
+                console.log(`  • ${chalk.red(error)}`);
+            });
+        }
+        // Show warnings
+        if (validation.warnings.length > 0) {
+            console.log(chalk.bold('\n⚠️  Warnings:'));
+            validation.warnings.forEach((warning)=>{
+                console.log(`  • ${chalk.yellow(warning)}`);
+            });
+        }
+        console.log(chalk.gray('\n' + '─'.repeat(50)));
+        if (validation.valid) {
+            console.log(chalk.green('\n🎉 Migration validation passed! Your project is ready to use optimized prompts.'));
+        } else {
+            console.log(chalk.red('\n⚠️  Migration validation failed. Please address the errors above.'));
+        }
+    }
+    constructor(){
+        _define_property(this, "requiredFiles", [
+            '.claude/commands/sparc.md',
+            '.claude/commands/claude-flow-help.md',
+            '.claude/commands/claude-flow-memory.md',
+            '.claude/BATCHTOOLS_GUIDE.md',
+            '.claude/BATCHTOOLS_BEST_PRACTICES.md'
+        ]);
+        _define_property(this, "requiredCommands", [
+            'sparc',
+            'sparc-architect',
+            'sparc-code',
+            'sparc-tdd',
+            'claude-flow-help',
+            'claude-flow-memory',
+            'claude-flow-swarm'
+        ]);
+    }
+}

package/dist/src/migration/progress-reporter.js

@@ -0,0 +1,150 @@
+/**
+ * Progress Reporter - Provides visual feedback during migration
+ */ function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+import * as chalk from "chalk";
+export class ProgressReporter {
+    start(phase, message) {
+        this.progress.phase = phase;
+        this.progress.current = message;
+        this.startTime = new Date();
+        console.log(chalk.bold(`\n🚀 Starting ${phase}...`));
+        this.startSpinner();
+    }
+    update(phase, message, completed, total) {
+        this.progress.phase = phase;
+        this.progress.current = message;
+        if (completed !== undefined) {
+            this.progress.completed = completed;
+        }
+        if (total !== undefined) {
+            this.progress.total = total;
+        }
+        this.updateDisplay();
+    }
+    complete(message) {
+        this.stopSpinner();
+        const duration = new Date().getTime() - this.startTime.getTime();
+        const seconds = (duration / 1000).toFixed(2);
+        console.log(chalk.green(`\n✅ ${message}`));
+        console.log(chalk.gray(`   Completed in ${seconds}s`));
+        if (this.progress.warnings > 0) {
+            console.log(chalk.yellow(`   ${this.progress.warnings} warnings`));
+        }
+        if (this.progress.errors > 0) {
+            console.log(chalk.red(`   ${this.progress.errors} errors`));
+        }
+    }
+    error(message) {
+        this.stopSpinner();
+        console.log(chalk.red(`\n❌ ${message}`));
+        this.progress.errors++;
+    }
+    warning(message) {
+        console.log(chalk.yellow(`⚠️  ${message}`));
+        this.progress.warnings++;
+    }
+    info(message) {
+        console.log(chalk.blue(`ℹ️  ${message}`));
+    }
+    startSpinner() {
+        this.intervalId = setInterval(()=>{
+            this.spinnerIndex = (this.spinnerIndex + 1) % this.spinner.length;
+            this.updateDisplay();
+        }, 100);
+    }
+    stopSpinner() {
+        if (this.intervalId) {
+            clearInterval(this.intervalId);
+            this.intervalId = null;
+        }
+        // Clear the spinner line
+        process.stdout.write('\r\x1b[K');
+    }
+    updateDisplay() {
+        const spinner = this.spinner[this.spinnerIndex];
+        const phase = this.getPhaseDisplay();
+        const progress = this.getProgressDisplay();
+        const message = `${spinner} ${phase} ${progress} ${this.progress.current}`;
+        // Clear line and write new message
+        process.stdout.write('\r\x1b[K' + message);
+    }
+    getPhaseDisplay() {
+        const phases = {
+            analyzing: chalk.blue('📊 Analyzing'),
+            'backing-up': chalk.yellow('💾 Backing up'),
+            migrating: chalk.green('🔄 Migrating'),
+            validating: chalk.cyan('✅ Validating'),
+            complete: chalk.green('✅ Complete')
+        };
+        return phases[this.progress.phase] || chalk.gray('⏳ Processing');
+    }
+    getProgressDisplay() {
+        if (this.progress.total > 0) {
+            const percentage = Math.round(this.progress.completed / this.progress.total * 100);
+            const progressBar = this.createProgressBar(percentage);
+            return `${progressBar} ${this.progress.completed}/${this.progress.total} (${percentage}%)`;
+        }
+        return '';
+    }
+    createProgressBar(percentage, width = 20) {
+        const filled = Math.round(percentage / 100 * width);
+        const empty = width - filled;
+        const filledBar = '█'.repeat(filled);
+        const emptyBar = '░'.repeat(empty);
+        return chalk.green(filledBar) + chalk.gray(emptyBar);
+    }
+    setTotal(total) {
+        this.progress.total = total;
+    }
+    increment(message) {
+        this.progress.completed++;
+        if (message) {
+            this.progress.current = message;
+        }
+        this.updateDisplay();
+    }
+    getProgress() {
+        return {
+            ...this.progress
+        };
+    }
+    constructor(){
+        _define_property(this, "progress", void 0);
+        _define_property(this, "startTime", void 0);
+        _define_property(this, "spinner", [
+            '⠋',
+            '⠙',
+            '⠹',
+            '⠸',
+            '⠼',
+            '⠴',
+            '⠦',
+            '⠧',
+            '⠇',
+            '⠏'
+        ]);
+        _define_property(this, "spinnerIndex", 0);
+        _define_property(this, "intervalId", null);
+        this.progress = {
+            total: 0,
+            completed: 0,
+            current: '',
+            phase: 'analyzing',
+            errors: 0,
+            warnings: 0
+        };
+        this.startTime = new Date();
+    }
+}