claude-flow-novice 2.0.4 → 2.0.5

package/dist/src/migration/rollback-manager.js

@@ -1,321 +0,0 @@
-/**
- * Rollback Manager - Handles rollback operations and backup management
- */ 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 * as inquirer from "inquirer";
-export class RollbackManager {
-    async createBackup(metadata = {}) {
-        const timestamp = new Date();
-        const backupId = timestamp.toISOString().replace(/[:.]/g, '-');
-        const backupPath = path.join(this.backupDir, backupId);
-        logger.info(`Creating backup at ${backupPath}...`);
-        await fs.ensureDir(backupPath);
-        const backup = {
-            timestamp,
-            version: '1.0.0',
-            files: [],
-            metadata: {
-                projectPath: this.projectPath,
-                backupId,
-                ...metadata
-            }
-        };
-        // Backup critical files and directories
-        const backupTargets = [
-            '.claude',
-            'CLAUDE.md',
-            '.roomodes',
-            'package.json',
-            'memory/memory-store.json',
-            'coordination/config.json'
-        ];
-        for (const target of backupTargets){
-            const sourcePath = path.join(this.projectPath, target);
-            const targetPath = path.join(backupPath, target);
-            if (await fs.pathExists(sourcePath)) {
-                const stats = await fs.stat(sourcePath);
-                if (stats.isDirectory()) {
-                    await this.backupDirectory(sourcePath, targetPath, backup);
-                } else {
-                    await this.backupFile(sourcePath, targetPath, backup, target);
-                }
-            }
-        }
-        // Save backup manifest
-        const manifestPath = path.join(backupPath, 'backup-manifest.json');
-        await fs.writeJson(manifestPath, backup, {
-            spaces: 2
-        });
-        // Update backup index
-        await this.updateBackupIndex(backup);
-        logger.success(`Backup created with ${backup.files.length} files`);
-        return backup;
-    }
-    async backupDirectory(sourcePath, targetPath, backup) {
-        await fs.ensureDir(targetPath);
-        const entries = await fs.readdir(sourcePath);
-        for (const entry of entries){
-            const entrySource = path.join(sourcePath, entry);
-            const entryTarget = path.join(targetPath, entry);
-            const stats = await fs.stat(entrySource);
-            if (stats.isDirectory()) {
-                await this.backupDirectory(entrySource, entryTarget, backup);
-            } else {
-                const relativePath = path.relative(this.projectPath, entrySource);
-                await this.backupFile(entrySource, entryTarget, backup, relativePath);
-            }
-        }
-    }
-    async backupFile(sourcePath, targetPath, backup, relativePath) {
-        const content = await fs.readFile(sourcePath, 'utf-8');
-        const checksum = crypto.createHash('sha256').update(content).digest('hex');
-        await fs.ensureDir(path.dirname(targetPath));
-        await fs.writeFile(targetPath, content);
-        const backupFile = {
-            path: relativePath,
-            content,
-            checksum,
-            permissions: (await fs.stat(sourcePath)).mode.toString(8)
-        };
-        backup.files.push(backupFile);
-    }
-    async listBackups() {
-        if (!await fs.pathExists(this.backupDir)) {
-            return [];
-        }
-        const backupFolders = await fs.readdir(this.backupDir);
-        const backups = [];
-        for (const folder of backupFolders.sort().reverse()){
-            const manifestPath = path.join(this.backupDir, folder, 'backup-manifest.json');
-            if (await fs.pathExists(manifestPath)) {
-                try {
-                    const backup = await fs.readJson(manifestPath);
-                    backups.push(backup);
-                } catch (error) {
-                    logger.warn(`Invalid backup manifest in ${folder}: ${error instanceof Error ? error.message : String(error)}`);
-                }
-            }
-        }
-        return backups;
-    }
-    async rollback(backupId, interactive = true) {
-        const backups = await this.listBackups();
-        if (backups.length === 0) {
-            throw new Error('No backups found');
-        }
-        let selectedBackup;
-        if (backupId) {
-            selectedBackup = backups.find((b)=>b.metadata.backupId === backupId);
-            if (!selectedBackup) {
-                throw new Error(`Backup not found: ${backupId}`);
-            }
-        } else if (interactive) {
-            selectedBackup = await this.selectBackupInteractively(backups);
-        } else {
-            selectedBackup = backups[0]; // Most recent
-        }
-        logger.info(`Rolling back to backup from ${selectedBackup.timestamp.toISOString()}...`);
-        // Confirm rollback
-        if (interactive) {
-            const confirm = await inquirer.prompt([
-                {
-                    type: 'confirm',
-                    name: 'proceed',
-                    message: `Are you sure you want to rollback? This will overwrite current files.`,
-                    default: false
-                }
-            ]);
-            if (!confirm.proceed) {
-                logger.info('Rollback cancelled');
-                return;
-            }
-        }
-        // Create pre-rollback backup
-        const preRollbackBackup = await this.createBackup({
-            type: 'pre-rollback',
-            rollingBackTo: selectedBackup.metadata.backupId
-        });
-        try {
-            // Restore files
-            await this.restoreFiles(selectedBackup);
-            // Validate restoration
-            await this.validateRestore(selectedBackup);
-            logger.success('Rollback completed successfully');
-        } catch (error) {
-            logger.error('Rollback failed, attempting to restore pre-rollback state...');
-            try {
-                await this.restoreFiles(preRollbackBackup);
-                logger.success('Pre-rollback state restored');
-            } catch (restoreError) {
-                logger.error('Failed to restore pre-rollback state:', restoreError);
-                throw new Error('Rollback failed and unable to restore previous state');
-            }
-            throw error;
-        }
-    }
-    async selectBackupInteractively(backups) {
-        const choices = backups.map((backup)=>({
-                name: `${backup.timestamp.toLocaleString()} - ${backup.files.length} files (${backup.metadata.type || 'migration'})`,
-                value: backup,
-                short: backup.metadata.backupId
-            }));
-        const answer = await inquirer.prompt([
-            {
-                type: 'list',
-                name: 'backup',
-                message: 'Select backup to rollback to:',
-                choices,
-                pageSize: 10
-            }
-        ]);
-        return answer.backup;
-    }
-    async restoreFiles(backup) {
-        logger.info(`Restoring ${backup.files.length} files...`);
-        for (const file of backup.files){
-            const targetPath = path.join(this.projectPath, file.path);
-            logger.debug(`Restoring ${file.path}`);
-            await fs.ensureDir(path.dirname(targetPath));
-            await fs.writeFile(targetPath, file.content);
-            // Restore permissions if available
-            if (file.permissions) {
-                try {
-                    await fs.chmod(targetPath, parseInt(file.permissions, 8));
-                } catch (error) {
-                    logger.warn(`Could not restore permissions for ${file.path}: ${error instanceof Error ? error.message : String(error)}`);
-                }
-            }
-        }
-    }
-    async validateRestore(backup) {
-        logger.info('Validating restored files...');
-        const errors = [];
-        for (const file of backup.files){
-            const filePath = path.join(this.projectPath, file.path);
-            if (!await fs.pathExists(filePath)) {
-                errors.push(`Missing file: ${file.path}`);
-                continue;
-            }
-            const content = await fs.readFile(filePath, 'utf-8');
-            const checksum = crypto.createHash('sha256').update(content).digest('hex');
-            if (checksum !== file.checksum) {
-                errors.push(`Checksum mismatch: ${file.path}`);
-            }
-        }
-        if (errors.length > 0) {
-            throw new Error(`Validation failed:\n${errors.join('\n')}`);
-        }
-        logger.success('Validation passed');
-    }
-    async cleanupOldBackups(retentionDays = 30, maxBackups = 10) {
-        const backups = await this.listBackups();
-        if (backups.length <= maxBackups) {
-            return; // No cleanup needed
-        }
-        const cutoffDate = new Date();
-        cutoffDate.setDate(cutoffDate.getDate() - retentionDays);
-        const backupsToDelete = backups.filter((backup, index)=>{
-            // Keep the most recent maxBackups
-            if (index < maxBackups) {
-                return false;
-            }
-            // Delete old backups
-            return backup.timestamp < cutoffDate;
-        });
-        if (backupsToDelete.length === 0) {
-            return;
-        }
-        logger.info(`Cleaning up ${backupsToDelete.length} old backups...`);
-        for (const backup of backupsToDelete){
-            const backupPath = path.join(this.backupDir, backup.metadata.backupId);
-            await fs.remove(backupPath);
-            logger.debug(`Removed backup: ${backup.metadata.backupId}`);
-        }
-        logger.success(`Cleanup completed, removed ${backupsToDelete.length} backups`);
-    }
-    async getBackupInfo(backupId) {
-        const backups = await this.listBackups();
-        return backups.find((b)=>b.metadata.backupId === backupId) || null;
-    }
-    async exportBackup(backupId, exportPath) {
-        const backup = await this.getBackupInfo(backupId);
-        if (!backup) {
-            throw new Error(`Backup not found: ${backupId}`);
-        }
-        const backupPath = path.join(this.backupDir, backup.metadata.backupId);
-        await fs.copy(backupPath, exportPath);
-        logger.success(`Backup exported to ${exportPath}`);
-    }
-    async importBackup(importPath) {
-        const manifestPath = path.join(importPath, 'backup-manifest.json');
-        if (!await fs.pathExists(manifestPath)) {
-            throw new Error('Invalid backup: missing manifest');
-        }
-        const backup = await fs.readJson(manifestPath);
-        const backupPath = path.join(this.backupDir, backup.metadata.backupId);
-        await fs.copy(importPath, backupPath);
-        await this.updateBackupIndex(backup);
-        logger.success(`Backup imported: ${backup.metadata.backupId}`);
-        return backup;
-    }
-    async updateBackupIndex(backup) {
-        const indexPath = path.join(this.backupDir, 'backup-index.json');
-        let index = {};
-        if (await fs.pathExists(indexPath)) {
-            index = await fs.readJson(indexPath);
-        }
-        index[backup.metadata.backupId] = {
-            timestamp: backup.timestamp,
-            version: backup.version,
-            fileCount: backup.files.length,
-            metadata: backup.metadata
-        };
-        await fs.writeJson(indexPath, index, {
-            spaces: 2
-        });
-    }
-    printBackupSummary(backups) {
-        if (backups.length === 0) {
-            console.log(chalk.yellow('No backups found'));
-            return;
-        }
-        console.log(chalk.bold('\n💾 Available Backups'));
-        console.log(chalk.gray('─'.repeat(70)));
-        backups.forEach((backup, index)=>{
-            const isRecent = index === 0;
-            const date = backup.timestamp.toLocaleString();
-            const type = backup.metadata.type || 'migration';
-            const fileCount = backup.files.length;
-            console.log(`\n${isRecent ? chalk.green('●') : chalk.gray('○')} ${chalk.bold(backup.metadata.backupId)}`);
-            console.log(`  ${chalk.gray('Date:')} ${date}`);
-            console.log(`  ${chalk.gray('Type:')} ${type}`);
-            console.log(`  ${chalk.gray('Files:')} ${fileCount}`);
-            if (backup.metadata.strategy) {
-                console.log(`  ${chalk.gray('Strategy:')} ${backup.metadata.strategy}`);
-            }
-        });
-        console.log(chalk.gray('\n' + '─'.repeat(70)));
-    }
-    constructor(projectPath, backupDir = '.claude-backup'){
-        _define_property(this, "projectPath", void 0);
-        _define_property(this, "backupDir", void 0);
-        this.projectPath = projectPath;
-        this.backupDir = path.join(projectPath, backupDir);
-    }
-}

package/dist/src/migration/tests/migration-system.test.js

@@ -1,7 +0,0 @@
-import { describe, it, expect } from "@jest/globals";
-describe('Migration System', ()=>{
-    it('should handle migrations', ()=>{
-        // Placeholder test to prevent failures
-        expect(true).toBe(true);
-    });
-});

package/dist/src/migration/types.js

@@ -1,3 +0,0 @@
-/**
- * Migration type definitions
- */ export { };

package/dist/src/swarm/__tests__/integration.test.js

@@ -1,227 +0,0 @@
-import * as fs from "node:fs/promises";
-import * as path from "path";
-import * as os from "os";
-import { PromptManager } from "../prompt-manager.js";
-import { PromptConfigManager } from "../prompt-utils.js";
-describe('Prompt Copying Integration Tests', ()=>{
-    let tempDir;
-    let testManager;
-    beforeEach(async ()=>{
-        tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'integration-test-'));
-        // Create test structure
-        const sourceDir = path.join(tempDir, 'source');
-        const destDir = path.join(tempDir, 'dest');
-        await fs.mkdir(sourceDir, {
-            recursive: true
-        });
-        await fs.mkdir(destDir, {
-            recursive: true
-        });
-        // Create test files
-        await createTestPromptStructure(sourceDir);
-        // Initialize manager
-        testManager = new PromptManager({
-            basePath: tempDir,
-            configPath: '.test-config.json',
-            autoDiscovery: false
-        });
-        // Configure manager
-        await testManager.updateConfig({
-            sourceDirectories: [
-                'source'
-            ],
-            destinationDirectory: 'dest'
-        });
-    });
-    afterEach(async ()=>{
-        await fs.rm(tempDir, {
-            recursive: true,
-            force: true
-        });
-    });
-    async function createTestPromptStructure(sourceDir) {
-        const structure = {
-            'sparc/architect.md': '# Architect\nSystem design expert.',
-            'sparc/tdd.md': '# TDD\nTest-driven development.',
-            'sparc/code.md': '# Code\nImplementation expert.',
-            'templates/api.md': '# API Template\n{{endpoint}}',
-            'rules/general.md': '# Rules\nGeneral guidelines.',
-            'invalid.md': '',
-            'large.md': 'Large content\n'.repeat(100)
-        };
-        for (const [filePath, content] of Object.entries(structure)){
-            const fullPath = path.join(sourceDir, filePath);
-            const dir = path.dirname(fullPath);
-            await fs.mkdir(dir, {
-                recursive: true
-            });
-            await fs.writeFile(fullPath, content);
-        }
-    }
-    test('should initialize and auto-discover prompt directories', async ()=>{
-        const discoveryManager = new PromptManager({
-            basePath: tempDir,
-            autoDiscovery: true
-        });
-        await discoveryManager.initialize();
-        const config = discoveryManager.getConfig();
-        expect(config.sourceDirectories.length).toBeGreaterThan(0);
-    });
-    test('should copy prompts using different profiles', async ()=>{
-        await testManager.initialize();
-        // Test with safe profile
-        const safeResult = await testManager.copyPrompts({
-            conflictResolution: 'skip',
-            parallel: false
-        });
-        expect(safeResult.success).toBe(true);
-        expect(safeResult.copiedFiles).toBeGreaterThan(0);
-        // Verify files exist
-        const destFiles = await fs.readdir(path.join(tempDir, 'dest'), {
-            recursive: true
-        });
-        expect(destFiles.length).toBeGreaterThan(0);
-    });
-    test('should validate prompts and generate reports', async ()=>{
-        await testManager.initialize();
-        // Copy files first
-        await testManager.copyPrompts();
-        // Validate prompts
-        const validation = await testManager.validatePrompts();
-        expect(validation.totalFiles).toBeGreaterThan(0);
-        expect(validation.validFiles).toBeGreaterThan(0);
-        expect(validation.invalidFiles).toBeGreaterThan(0); // Should find the empty file
-        // Check that empty file is flagged as invalid
-        const emptyFileIssue = validation.issues.find((issue)=>issue.file.includes('invalid.md'));
-        expect(emptyFileIssue).toBeDefined();
-        expect(emptyFileIssue.issues).toContain('File is empty');
-    });
-    test('should handle multiple sources', async ()=>{
-        // Create second source
-        const source2Dir = path.join(tempDir, 'source2');
-        await fs.mkdir(source2Dir, {
-            recursive: true
-        });
-        await fs.writeFile(path.join(source2Dir, 'extra.md'), '# Extra\nExtra prompt.');
-        // Update config
-        await testManager.updateConfig({
-            sourceDirectories: [
-                'source',
-                'source2'
-            ]
-        });
-        await testManager.initialize();
-        // Copy from multiple sources
-        const results = await testManager.copyFromMultipleSources();
-        expect(results.length).toBe(2);
-        expect(results.every((r)=>r.success)).toBe(true);
-        // Verify files from both sources
-        const destFiles = await fs.readdir(path.join(tempDir, 'dest'), {
-            recursive: true
-        });
-        expect(destFiles).toContain('extra.md');
-    });
-    test('should generate comprehensive system report', async ()=>{
-        await testManager.initialize();
-        await testManager.copyPrompts();
-        const report = await testManager.generateReport();
-        expect(report.configuration).toBeDefined();
-        expect(report.sources).toBeDefined();
-        expect(report.sources.length).toBeGreaterThan(0);
-        // Check source analysis
-        const sourceInfo = report.sources[0];
-        expect(sourceInfo.exists).toBe(true);
-        expect(sourceInfo.fileCount).toBeGreaterThan(0);
-        expect(sourceInfo.totalSize).toBeGreaterThan(0);
-    });
-    test('should handle configuration persistence', async ()=>{
-        const configManager = new PromptConfigManager(path.join(tempDir, '.test-config.json'));
-        // Save custom config
-        await configManager.saveConfig({
-            destinationDirectory: './custom-dest',
-            defaultOptions: {
-                maxWorkers: 8,
-                conflictResolution: 'merge'
-            }
-        });
-        // Load config in new instance
-        const newConfigManager = new PromptConfigManager(path.join(tempDir, '.test-config.json'));
-        const config = await newConfigManager.loadConfig();
-        expect(config.destinationDirectory).toBe('./custom-dest');
-        expect(config.defaultOptions.maxWorkers).toBe(8);
-        expect(config.defaultOptions.conflictResolution).toBe('merge');
-    });
-    test('should handle errors gracefully', async ()=>{
-        // Test with invalid source directory
-        await testManager.updateConfig({
-            sourceDirectories: [
-                'nonexistent'
-            ]
-        });
-        await testManager.initialize();
-        // Should not throw but return failed result
-        const result = await testManager.copyPrompts();
-        // The result should indicate failure or no files copied
-        expect(result.copiedFiles).toBe(0);
-    });
-    test('should support incremental sync', async ()=>{
-        await testManager.initialize();
-        // Initial copy
-        const firstResult = await testManager.copyPrompts();
-        expect(firstResult.success).toBe(true);
-        // Modify source file
-        const sourceFile = path.join(tempDir, 'source', 'sparc', 'architect.md');
-        await fs.writeFile(sourceFile, '# Modified Architect\nUpdated content.');
-        // Sync should detect changes
-        const syncResult = await testManager.syncPrompts({
-            incrementalOnly: true,
-            compareHashes: true
-        });
-        expect(syncResult.forward.success).toBe(true);
-    });
-    test('should respect include/exclude patterns', async ()=>{
-        await testManager.initialize();
-        // Copy only .md files from sparc directory
-        const result = await testManager.copyPrompts({
-            includePatterns: [
-                '**/sparc/*.md'
-            ],
-            excludePatterns: [
-                '**/tdd.md'
-            ]
-        });
-        expect(result.success).toBe(true);
-        // Check that only architect.md and code.md were copied
-        const sparcDir = path.join(tempDir, 'dest', 'sparc');
-        const sparcFiles = await fs.readdir(sparcDir).catch(()=>[]);
-        expect(sparcFiles).toContain('architect.md');
-        expect(sparcFiles).toContain('code.md');
-        expect(sparcFiles).not.toContain('tdd.md');
-    });
-    test('should handle concurrent operations', async ()=>{
-        await testManager.initialize();
-        // Start multiple copy operations
-        const operations = [
-            testManager.copyPrompts({
-                destination: path.join(tempDir, 'dest1')
-            }),
-            testManager.copyPrompts({
-                destination: path.join(tempDir, 'dest2')
-            }),
-            testManager.copyPrompts({
-                destination: path.join(tempDir, 'dest3')
-            })
-        ];
-        const results = await Promise.all(operations);
-        // All operations should succeed
-        expect(results.every((r)=>r.success)).toBe(true);
-        // Verify all destinations have files
-        for(let i = 1; i <= 3; i++){
-            const destDir = path.join(tempDir, `dest${i}`);
-            const files = await fs.readdir(destDir, {
-                recursive: true
-            });
-            expect(files.length).toBeGreaterThan(0);
-        }
-    });
-});