claude-flow-novice 2.0.3 → 2.0.4

package/dist/src/migration/index.js

@@ -0,0 +1,92 @@
+#!/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

@@ -0,0 +1,121 @@
+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

@@ -0,0 +1,268 @@
+/**
+ * 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'
+        ]);
+    }
+}