claude-flow-novice 2.0.6 → 2.0.8

package/dist/src/hooks/index.js

@@ -7,9 +7,9 @@
  *
  * This file provides backward compatibility redirects while we complete the migration.
  */ // Re-export the modern agentic-flow-hooks system
-export { agenticHookManager, initializeAgenticFlowHooks } from "../services/agentic-flow-hooks";
+export { agenticHookManager, initializeAgenticFlowHooks } from "../services/agentic-flow-hooks/index.js";
 // Re-export verification system
-export { verificationHookManager, initializeVerificationSystem, getVerificationSystemStatus, shutdownVerificationSystem } from "../verification";
+export { verificationHookManager, initializeVerificationSystem, getVerificationSystemStatus, shutdownVerificationSystem } from "../verification/index.js";
 // Legacy hook templates for backward compatibility
 export const QUALITY_HOOKS = {
     CODE_QUALITY: {
@@ -187,8 +187,8 @@ agentic-flow-hooks system for better performance and functionality.
   - See docs/maestro/specs/hooks-refactoring-plan.md for details
 
 🚀 Get Started:
-  import { agenticHookManager, initializeAgenticFlowHooks } from '../services/agentic-flow-hooks/'
-  import { verificationHookManager, initializeVerificationSystem } from '../verification/'
+  import { agenticHookManager, initializeAgenticFlowHooks } from '../services/agentic-flow-hooks//index.js'
+  import { verificationHookManager, initializeVerificationSystem } from '../verification//index.js'
   await initializeAgenticFlowHooks()
   await initializeVerificationSystem()
   agenticHookManager.register({ ... })

package/dist/src/migration/dist/index.d.js

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+/**
+ * Claude-Flow Migration Tool
+ * Helps existing projects migrate to optimized prompts and configurations
+ */ export { }; //# sourceMappingURL=index.d.ts.map

package/dist/src/migration/dist/index.js

@@ -0,0 +1,166 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * Claude-Flow Migration Tool
+ * Helps existing projects migrate to optimized prompts and configurations
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const command_1 = require("@cliffy/command");
+const migration_runner_js_1 = require("./migration-runner.js");
+const migration_analyzer_js_1 = require("./migration-analyzer.js");
+const logger_js_1 = require("./logger.js");
+const path = __importStar(require("path"));
+const program = new command_1.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 migration_analyzer_js_1.MigrationAnalyzer();
+        const analysis = await analyzer.analyze(path.resolve(projectPath));
+        if (options.output) {
+            await analyzer.saveAnalysis(analysis, options.output);
+            logger_js_1.logger.success(`Analysis saved to ${options.output}`);
+        }
+        analyzer.printAnalysis(analysis, options.detailed);
+    }
+    catch (error) {
+        logger_js_1.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 migration_runner_js_1.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_js_1.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 migration_runner_js_1.MigrationRunner({
+            projectPath: path.resolve(projectPath),
+            strategy: 'full',
+            backupDir: options.backup,
+            force: options.force,
+        });
+        await runner.rollback(options.timestamp);
+    }
+    catch (error) {
+        logger_js_1.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 migration_runner_js_1.MigrationRunner({
+            projectPath: path.resolve(projectPath),
+            strategy: 'full',
+        });
+        const isValid = await runner.validate(options.verbose);
+        if (isValid) {
+            logger_js_1.logger.success('Migration validated successfully!');
+        }
+        else {
+            logger_js_1.logger.error('Migration validation failed');
+            process.exit(1);
+        }
+    }
+    catch (error) {
+        logger_js_1.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 migration_runner_js_1.MigrationRunner({
+            projectPath: path.resolve(projectPath),
+            strategy: 'full',
+            backupDir: options.backup,
+        });
+        await runner.listBackups();
+    }
+    catch (error) {
+        logger_js_1.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);
+//# sourceMappingURL=index.js.map

package/dist/src/migration/dist/logger.d.js

@@ -0,0 +1 @@
+export { }; //# sourceMappingURL=logger.d.ts.map

package/dist/src/migration/dist/logger.js

@@ -0,0 +1,144 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logger = exports.MigrationLogger = void 0;
+const process = __importStar(require("node:process"));
+/**
+ * Migration Logger - Structured logging for migration operations
+ */
+const fs = __importStar(require("fs-extra"));
+const path = __importStar(require("path"));
+const chalk = __importStar(require("chalk"));
+class MigrationLogger {
+    constructor(logFile) {
+        this.entries = [];
+        this.logFile = logFile;
+    }
+    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)));
+    }
+}
+exports.MigrationLogger = MigrationLogger;
+// Global logger instance
+exports.logger = new MigrationLogger();
+// Set log file if in production
+if (process.env.NODE_ENV === 'production') {
+    const logFile = path.join(process.cwd(), 'logs', 'migration.log');
+    exports.logger['logFile'] = logFile;
+}
+//# sourceMappingURL=logger.js.map

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

@@ -0,0 +1,3 @@
+/**
+ * Migration Analyzer - Analyzes existing projects for migration readiness
+ */ export { }; //# sourceMappingURL=migration-analyzer.d.ts.map

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

@@ -0,0 +1,286 @@
+"use strict";
+/**
+ * Migration Analyzer - Analyzes existing projects for migration readiness
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MigrationAnalyzer = void 0;
+const fs = __importStar(require("fs-extra"));
+const path = __importStar(require("path"));
+const crypto = __importStar(require("crypto"));
+const logger_js_1 = require("./logger.js");
+const chalk = __importStar(require("chalk"));
+const glob_1 = require("glob");
+class MigrationAnalyzer {
+    constructor() {
+        this.optimizedCommands = [
+            'sparc',
+            'sparc-architect',
+            'sparc-code',
+            'sparc-tdd',
+            'claude-flow-help',
+            'claude-flow-memory',
+            'claude-flow-swarm',
+        ];
+    }
+    async analyze(projectPath) {
+        logger_js_1.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 (0, glob_1.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 });
+    }
+}
+exports.MigrationAnalyzer = MigrationAnalyzer;
+//# sourceMappingURL=migration-analyzer.js.map

package/dist/src/migration/dist/migration-runner.d.js

@@ -0,0 +1 @@
+export { }; //# sourceMappingURL=migration-runner.d.ts.map