claude-flow-novice 2.0.4 → 2.0.5

package/dist/src/migration/index.js

@@ -1,92 +0,0 @@
-#!/usr/bin/env node
-/**
- * Claude-Flow Migration Tool
- * Helps existing projects migrate to optimized prompts and configurations
- */ import { Command } from "@cliffy/command";
-import { MigrationRunner } from "./migration-runner.js";
-import { MigrationAnalyzer } from "./migration-analyzer.js";
-import { logger } from "./logger.js";
-import * as path from "path";
-const program = new Command();
-program.name('claude-flow-migrate').description('Migrate existing claude-flow-novice projects to optimized prompts').version('1.0.0');
-program.command('analyze [path]').description('Analyze existing project for migration readiness').option('-d, --detailed', 'Show detailed analysis').option('-o, --output <file>', 'Output analysis to file').action(async (projectPath = '.', options)=>{
-    try {
-        const analyzer = new MigrationAnalyzer();
-        const analysis = await analyzer.analyze(path.resolve(projectPath));
-        if (options.output) {
-            await analyzer.saveAnalysis(analysis, options.output);
-            logger.success(`Analysis saved to ${options.output}`);
-        }
-        analyzer.printAnalysis(analysis, options.detailed);
-    } catch (error) {
-        logger.error('Analysis failed:', error);
-        process.exit(1);
-    }
-});
-program.command('migrate [path]').description('Migrate project to optimized prompts').option('-s, --strategy <type>', 'Migration strategy: full, selective, merge', 'selective').option('-b, --backup <dir>', 'Backup directory', '.claude-backup').option('-f, --force', 'Force migration without prompts').option('--dry-run', 'Simulate migration without making changes').option('--preserve-custom', 'Preserve custom commands and configurations').option('--skip-validation', 'Skip post-migration validation').action(async (projectPath = '.', options)=>{
-    try {
-        const runner = new MigrationRunner({
-            projectPath: path.resolve(projectPath),
-            strategy: options.strategy,
-            backupDir: options.backup,
-            force: options.force,
-            dryRun: options.dryRun,
-            preserveCustom: options.preserveCustom,
-            skipValidation: options.skipValidation
-        });
-        await runner.run();
-    } catch (error) {
-        logger.error('Migration failed:', error);
-        process.exit(1);
-    }
-});
-program.command('rollback [path]').description('Rollback to previous configuration').option('-b, --backup <dir>', 'Backup directory to restore from', '.claude-backup').option('-t, --timestamp <time>', 'Restore from specific timestamp').option('-f, --force', 'Force rollback without prompts').action(async (projectPath = '.', options)=>{
-    try {
-        const runner = new MigrationRunner({
-            projectPath: path.resolve(projectPath),
-            strategy: 'full',
-            backupDir: options.backup,
-            force: options.force
-        });
-        await runner.rollback(options.timestamp);
-    } catch (error) {
-        logger.error('Rollback failed:', error);
-        process.exit(1);
-    }
-});
-program.command('validate [path]').description('Validate migration was successful').option('-v, --verbose', 'Show detailed validation results').action(async (projectPath = '.', options)=>{
-    try {
-        const runner = new MigrationRunner({
-            projectPath: path.resolve(projectPath),
-            strategy: 'full'
-        });
-        const isValid = await runner.validate(options.verbose);
-        if (isValid) {
-            logger.success('Migration validated successfully!');
-        } else {
-            logger.error('Migration validation failed');
-            process.exit(1);
-        }
-    } catch (error) {
-        logger.error('Validation failed:', error);
-        process.exit(1);
-    }
-});
-program.command('list-backups [path]').description('List available backups').option('-b, --backup <dir>', 'Backup directory', '.claude-backup').action(async (projectPath = '.', options)=>{
-    try {
-        const runner = new MigrationRunner({
-            projectPath: path.resolve(projectPath),
-            strategy: 'full',
-            backupDir: options.backup
-        });
-        await runner.listBackups();
-    } catch (error) {
-        logger.error('Failed to list backups:', error);
-        process.exit(1);
-    }
-});
-// Show help if no command provided
-if (!process.argv.slice(2).length) {
-    program.outputHelp();
-}
-program.parse(process.argv);

package/dist/src/migration/logger.js

@@ -1,121 +0,0 @@
-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 process from "node:process";
-/**
- * Migration Logger - Structured logging for migration operations
- */ import * as fs from "fs-extra";
-import * as path from "path";
-import * as chalk from "chalk";
-export class MigrationLogger {
-    info(message, context) {
-        this.log('info', message, context);
-        console.log(chalk.blue(`ℹ️  ${message}`));
-    }
-    warn(message, context) {
-        this.log('warn', message, context);
-        console.log(chalk.yellow(`⚠️  ${message}`));
-    }
-    error(message, error, context) {
-        this.log('error', message, context, error?.stack);
-        console.log(chalk.red(`❌ ${message}`));
-        if (error && (error instanceof Error ? error.message : String(error)) !== message) {
-            console.log(chalk.red(`   ${error instanceof Error ? error.message : String(error)}`));
-        }
-    }
-    success(message, context) {
-        this.log('success', message, context);
-        console.log(chalk.green(`✅ ${message}`));
-    }
-    debug(message, context) {
-        if (process.env.DEBUG === 'true' || process.env.NODE_ENV === 'development') {
-            this.log('debug', message, context);
-            console.log(chalk.gray(`🔍 ${message}`));
-        }
-    }
-    log(level, message, context, stack) {
-        const entry = {
-            timestamp: new Date(),
-            level,
-            message,
-            context,
-            stack
-        };
-        this.entries.push(entry);
-        if (this.logFile) {
-            this.writeToFile(entry);
-        }
-    }
-    async writeToFile(entry) {
-        if (!this.logFile) return;
-        try {
-            const logDir = path.dirname(this.logFile);
-            await fs.ensureDir(logDir);
-            const logLine = JSON.stringify(entry) + '\n';
-            await fs.appendFile(this.logFile, logLine);
-        } catch (error) {
-            // Prevent recursive logging
-            console.error('Failed to write to log file:', error instanceof Error ? error.message : String(error));
-        }
-    }
-    async saveToFile(filePath) {
-        await fs.ensureDir(path.dirname(filePath));
-        await fs.writeJson(filePath, this.entries, {
-            spaces: 2
-        });
-    }
-    getEntries() {
-        return [
-            ...this.entries
-        ];
-    }
-    getEntriesByLevel(level) {
-        return this.entries.filter((entry)=>entry.level === level);
-    }
-    clear() {
-        this.entries = [];
-    }
-    printSummary() {
-        const summary = {
-            total: this.entries.length,
-            info: this.getEntriesByLevel('info').length,
-            warn: this.getEntriesByLevel('warn').length,
-            error: this.getEntriesByLevel('error').length,
-            success: this.getEntriesByLevel('success').length,
-            debug: this.getEntriesByLevel('debug').length
-        };
-        console.log(chalk.bold('\n📊 Migration Log Summary'));
-        console.log(chalk.gray('─'.repeat(30)));
-        console.log(`Total entries: ${summary.total}`);
-        console.log(`${chalk.blue('Info:')} ${summary.info}`);
-        console.log(`${chalk.green('Success:')} ${summary.success}`);
-        console.log(`${chalk.yellow('Warnings:')} ${summary.warn}`);
-        console.log(`${chalk.red('Errors:')} ${summary.error}`);
-        if (summary.debug > 0) {
-            console.log(`${chalk.gray('Debug:')} ${summary.debug}`);
-        }
-        console.log(chalk.gray('─'.repeat(30)));
-    }
-    constructor(logFile){
-        _define_property(this, "logFile", void 0);
-        _define_property(this, "entries", []);
-        this.logFile = logFile;
-    }
-}
-// Global logger instance
-export const logger = new MigrationLogger();
-// Set log file if in production
-if (process.env.NODE_ENV === 'production') {
-    const logFile = path.join(process.cwd(), 'logs', 'migration.log');
-    logger['logFile'] = logFile;
-}

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

@@ -1,268 +0,0 @@
-/**
- * Migration Analyzer - Analyzes existing projects for migration readiness
- */ 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 crypto from "crypto";
-import { logger } from "./logger.js";
-import * as chalk from "chalk";
-import { glob } from "glob";
-export class MigrationAnalyzer {
-    async analyze(projectPath) {
-        logger.info(`Analyzing project at ${projectPath}...`);
-        const analysis = {
-            projectPath,
-            hasClaudeFolder: false,
-            hasOptimizedPrompts: false,
-            customCommands: [],
-            customConfigurations: {},
-            conflictingFiles: [],
-            migrationRisks: [],
-            recommendations: [],
-            timestamp: new Date()
-        };
-        // Check for .claude folder
-        const claudePath = path.join(projectPath, '.claude');
-        if (await fs.pathExists(claudePath)) {
-            analysis.hasClaudeFolder = true;
-            // Analyze existing commands
-            await this.analyzeCommands(claudePath, analysis);
-            // Check for optimized prompts
-            await this.checkOptimizedPrompts(claudePath, analysis);
-            // Analyze configurations
-            await this.analyzeConfigurations(projectPath, analysis);
-            // Detect conflicts
-            await this.detectConflicts(projectPath, analysis);
-        }
-        // Generate risks and recommendations
-        this.assessRisks(analysis);
-        this.generateRecommendations(analysis);
-        return analysis;
-    }
-    async analyzeCommands(claudePath, analysis) {
-        const commandsPath = path.join(claudePath, 'commands');
-        if (await fs.pathExists(commandsPath)) {
-            const files = await glob('**/*.md', {
-                cwd: commandsPath
-            });
-            for (const file of files){
-                const commandName = path.basename(file, '.md');
-                if (!this.optimizedCommands.includes(commandName)) {
-                    analysis.customCommands.push(commandName);
-                }
-            }
-        }
-    }
-    async checkOptimizedPrompts(claudePath, analysis) {
-        // Check for key optimized prompt files
-        const optimizedFiles = [
-            'BATCHTOOLS_GUIDE.md',
-            'BATCHTOOLS_BEST_PRACTICES.md',
-            'MIGRATION_GUIDE.md',
-            'PERFORMANCE_BENCHMARKS.md'
-        ];
-        let hasOptimized = 0;
-        for (const file of optimizedFiles){
-            if (await fs.pathExists(path.join(claudePath, file))) {
-                hasOptimized++;
-            }
-        }
-        analysis.hasOptimizedPrompts = hasOptimized >= 2;
-    }
-    async analyzeConfigurations(projectPath, analysis) {
-        // Check for CLAUDE.md
-        const claudeMdPath = path.join(projectPath, 'CLAUDE.md');
-        if (await fs.pathExists(claudeMdPath)) {
-            const content = await fs.readFile(claudeMdPath, 'utf-8');
-            analysis.customConfigurations['CLAUDE.md'] = {
-                exists: true,
-                size: content.length,
-                hasCustomContent: !content.includes('SPARC Development Environment')
-            };
-        }
-        // Check for .roomodes
-        const roomodesPath = path.join(projectPath, '.roomodes');
-        if (await fs.pathExists(roomodesPath)) {
-            try {
-                const roomodes = await fs.readJson(roomodesPath);
-                analysis.customConfigurations['.roomodes'] = {
-                    exists: true,
-                    modeCount: Object.keys(roomodes).length,
-                    customModes: Object.keys(roomodes).filter((mode)=>![
-                            'architect',
-                            'code',
-                            'tdd',
-                            'debug',
-                            'docs-writer'
-                        ].includes(mode))
-                };
-            } catch (error) {
-                analysis.migrationRisks.push({
-                    level: 'medium',
-                    description: 'Invalid .roomodes file',
-                    file: roomodesPath,
-                    mitigation: 'File will be backed up and replaced'
-                });
-            }
-        }
-    }
-    async detectConflicts(projectPath, analysis) {
-        // Check for files that might conflict with migration
-        const potentialConflicts = [
-            '.claude/commands/sparc.md',
-            '.claude/BATCHTOOLS_GUIDE.md',
-            'memory/memory-store.json',
-            'coordination/config.json'
-        ];
-        for (const file of potentialConflicts){
-            const filePath = path.join(projectPath, file);
-            if (await fs.pathExists(filePath)) {
-                const content = await fs.readFile(filePath, 'utf-8');
-                const checksum = crypto.createHash('md5').update(content).digest('hex');
-                // Check if it's a custom version
-                if (!this.isStandardFile(file, checksum)) {
-                    analysis.conflictingFiles.push(file);
-                }
-            }
-        }
-    }
-    isStandardFile(file, checksum) {
-        // This would contain checksums of standard files
-        // For now, we'll assume all existing files are potentially custom
-        return false;
-    }
-    assessRisks(analysis) {
-        // High risk: Custom commands that might be overwritten
-        if (analysis.customCommands.length > 0) {
-            analysis.migrationRisks.push({
-                level: 'high',
-                description: `Found ${analysis.customCommands.length} custom commands that may be affected`,
-                mitigation: 'Use --preserve-custom flag or selective migration'
-            });
-        }
-        // Medium risk: Existing optimized prompts
-        if (analysis.hasOptimizedPrompts) {
-            analysis.migrationRisks.push({
-                level: 'medium',
-                description: 'Project already has some optimized prompts',
-                mitigation: 'Consider using merge strategy to preserve customizations'
-            });
-        }
-        // Low risk: No .claude folder
-        if (!analysis.hasClaudeFolder) {
-            analysis.migrationRisks.push({
-                level: 'low',
-                description: 'No existing .claude folder found',
-                mitigation: 'Fresh installation will be performed'
-            });
-        }
-        // High risk: Conflicting files
-        if (analysis.conflictingFiles.length > 0) {
-            analysis.migrationRisks.push({
-                level: 'high',
-                description: `${analysis.conflictingFiles.length} files may have custom modifications`,
-                mitigation: 'Files will be backed up before migration'
-            });
-        }
-    }
-    generateRecommendations(analysis) {
-        // Strategy recommendations
-        if (analysis.customCommands.length > 0 || analysis.conflictingFiles.length > 0) {
-            analysis.recommendations.push('Use "selective" or "merge" strategy to preserve customizations');
-        } else if (!analysis.hasClaudeFolder) {
-            analysis.recommendations.push('Use "full" strategy for clean installation');
-        }
-        // Backup recommendations
-        if (analysis.hasClaudeFolder) {
-            analysis.recommendations.push('Create a backup before migration (automatic with default settings)');
-        }
-        // Custom command recommendations
-        if (analysis.customCommands.length > 0) {
-            analysis.recommendations.push(`Review custom commands: ${analysis.customCommands.join(', ')}`);
-        }
-        // Validation recommendations
-        if (analysis.migrationRisks.some((r)=>r.level === 'high')) {
-            analysis.recommendations.push('Run with --dry-run first to preview changes');
-        }
-    }
-    printAnalysis(analysis, detailed = false) {
-        console.log(chalk.bold('\n📊 Migration Analysis Report'));
-        console.log(chalk.gray('─'.repeat(50)));
-        console.log(`\n${chalk.bold('Project:')} ${analysis.projectPath}`);
-        console.log(`${chalk.bold('Timestamp:')} ${analysis.timestamp.toISOString()}`);
-        // Status
-        console.log(chalk.bold('\n📋 Current Status:'));
-        console.log(`  • .claude folder: ${analysis.hasClaudeFolder ? chalk.green('✓') : chalk.red('✗')}`);
-        console.log(`  • Optimized prompts: ${analysis.hasOptimizedPrompts ? chalk.green('✓') : chalk.red('✗')}`);
-        console.log(`  • Custom commands: ${analysis.customCommands.length > 0 ? chalk.yellow(analysis.customCommands.length) : chalk.green('0')}`);
-        console.log(`  • Conflicts: ${analysis.conflictingFiles.length > 0 ? chalk.yellow(analysis.conflictingFiles.length) : chalk.green('0')}`);
-        // Risks
-        if (analysis.migrationRisks.length > 0) {
-            console.log(chalk.bold('\n⚠️  Migration Risks:'));
-            analysis.migrationRisks.forEach((risk)=>{
-                const icon = risk.level === 'high' ? '🔴' : risk.level === 'medium' ? '🟡' : '🟢';
-                console.log(`  ${icon} ${chalk.bold(risk.level.toUpperCase())}: ${risk.description}`);
-                if (risk.mitigation) {
-                    console.log(`     ${chalk.gray('→')} ${chalk.italic(risk.mitigation)}`);
-                }
-            });
-        }
-        // Recommendations
-        if (analysis.recommendations.length > 0) {
-            console.log(chalk.bold('\n💡 Recommendations:'));
-            analysis.recommendations.forEach((rec)=>{
-                console.log(`  • ${rec}`);
-            });
-        }
-        // Detailed information
-        if (detailed) {
-            if (analysis.customCommands.length > 0) {
-                console.log(chalk.bold('\n🔧 Custom Commands:'));
-                analysis.customCommands.forEach((cmd)=>{
-                    console.log(`  • ${cmd}`);
-                });
-            }
-            if (analysis.conflictingFiles.length > 0) {
-                console.log(chalk.bold('\n📁 Conflicting Files:'));
-                analysis.conflictingFiles.forEach((file)=>{
-                    console.log(`  • ${file}`);
-                });
-            }
-            if (Object.keys(analysis.customConfigurations).length > 0) {
-                console.log(chalk.bold('\n⚙️  Configurations:'));
-                Object.entries(analysis.customConfigurations).forEach(([file, config])=>{
-                    console.log(`  • ${file}: ${JSON.stringify(config, null, 2)}`);
-                });
-            }
-        }
-        console.log(chalk.gray('\n' + '─'.repeat(50)));
-    }
-    async saveAnalysis(analysis, outputPath) {
-        await fs.writeJson(outputPath, analysis, {
-            spaces: 2
-        });
-    }
-    constructor(){
-        _define_property(this, "optimizedCommands", [
-            'sparc',
-            'sparc-architect',
-            'sparc-code',
-            'sparc-tdd',
-            'claude-flow-help',
-            'claude-flow-memory',
-            'claude-flow-swarm'
-        ]);
-    }
-}