claude-flow-novice 2.0.4 → 2.0.5

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

@@ -1,285 +0,0 @@
-/**
- * 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

@@ -1,150 +0,0 @@
-/**
- * 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();
-    }
-}