claude-flow-novice 2.0.4 → 2.0.5

package/dist/src/swarm/prompt-copier.js

@@ -1,381 +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 fs from "node:fs/promises";
-import * as path from "path";
-import { createHash } from "crypto";
-import { EventEmitter } from "events";
-import { logger } from "../core/logger.js";
-export class PromptCopier extends EventEmitter {
-    async copy() {
-        const startTime = Date.now();
-        try {
-            // Phase 1: Discovery
-            logger.info('Starting prompt discovery phase...');
-            await this.discoverFiles();
-            if (this.fileQueue.length === 0) {
-                return {
-                    success: true,
-                    totalFiles: 0,
-                    copiedFiles: 0,
-                    failedFiles: 0,
-                    skippedFiles: 0,
-                    duration: Date.now() - startTime,
-                    errors: []
-                };
-            }
-            // Phase 2: Pre-flight checks
-            if (!this.options.dryRun) {
-                await this.ensureDestinationDirectories();
-            }
-            // Phase 3: Copy files
-            logger.info(`Copying ${this.fileQueue.length} files...`);
-            if (this.options.parallel) {
-                await this.copyFilesParallel();
-            } else {
-                await this.copyFilesSequential();
-            }
-            // Phase 4: Verification
-            if (this.options.verify && !this.options.dryRun) {
-                await this.verifyFiles();
-            }
-            const duration = Date.now() - startTime;
-            const result = {
-                success: this.errors.length === 0,
-                totalFiles: this.fileQueue.length,
-                copiedFiles: this.copiedFiles.size,
-                failedFiles: this.errors.length,
-                skippedFiles: this.fileQueue.length - this.copiedFiles.size - this.errors.length,
-                errors: this.errors,
-                duration
-            };
-            if (this.backupMap.size > 0) {
-                result.backupLocation = await this.createBackupManifest();
-            }
-            logger.info(`Copy completed in ${duration}ms`, result);
-            return result;
-        } catch (error) {
-            logger.error('Copy operation failed', error);
-            if (!this.options.dryRun) {
-                await this.rollback();
-            }
-            throw error;
-        }
-    }
-    async discoverFiles() {
-        const sourceStats = await fs.stat(this.options.source);
-        if (!sourceStats.isDirectory()) {
-            throw new Error(`Source path ${this.options.source} is not a directory`);
-        }
-        await this.scanDirectory(this.options.source, '');
-        // Sort by size for better parallel distribution
-        this.fileQueue.sort((a, b)=>b.size - a.size);
-    }
-    async scanDirectory(dirPath, relativePath) {
-        const entries = await fs.readdir(dirPath, {
-            withFileTypes: true
-        });
-        for (const entry of entries){
-            const fullPath = path.join(dirPath, entry.name);
-            const relPath = path.join(relativePath, entry.name);
-            if (entry.isDirectory()) {
-                await this.scanDirectory(fullPath, relPath);
-            } else if (entry.isFile() && this.shouldIncludeFile(relPath)) {
-                const stats = await fs.stat(fullPath);
-                this.fileQueue.push({
-                    path: fullPath,
-                    relativePath: relPath,
-                    size: stats.size,
-                    permissions: stats.mode
-                });
-            }
-        }
-    }
-    shouldIncludeFile(filePath) {
-        // Check exclude patterns first
-        for (const pattern of this.options.excludePatterns){
-            if (this.matchPattern(filePath, pattern)) {
-                return false;
-            }
-        }
-        // Check include patterns
-        if (this.options.includePatterns.length === 0) {
-            return true;
-        }
-        for (const pattern of this.options.includePatterns){
-            if (this.matchPattern(filePath, pattern)) {
-                return true;
-            }
-        }
-        return false;
-    }
-    matchPattern(filePath, pattern) {
-        // Simple glob pattern matching
-        const regex = pattern.replace(/\./g, '\\.').replace(/\*/g, '.*').replace(/\?/g, '.');
-        return new RegExp(regex).test(filePath);
-    }
-    async ensureDestinationDirectories() {
-        const directories = new Set();
-        for (const file of this.fileQueue){
-            const destDir = path.dirname(path.join(this.options.destination, file.relativePath));
-            directories.add(destDir);
-        }
-        // Create directories in order (parent first)
-        const sortedDirs = Array.from(directories).sort((a, b)=>a.length - b.length);
-        for (const dir of sortedDirs){
-            await fs.mkdir(dir, {
-                recursive: true
-            });
-        }
-    }
-    async copyFilesSequential() {
-        let completed = 0;
-        for (const file of this.fileQueue){
-            try {
-                await this.copyFile(file);
-                completed++;
-                this.reportProgress(completed);
-            } catch (error) {
-                this.errors.push({
-                    file: file.path,
-                    error: error instanceof Error ? error.message : String(error),
-                    phase: 'write'
-                });
-            }
-        }
-    }
-    async copyFilesParallel() {
-        const workerCount = Math.min(this.options.maxWorkers, this.fileQueue.length);
-        const chunkSize = Math.ceil(this.fileQueue.length / workerCount);
-        const workers = [];
-        for(let i = 0; i < workerCount; i++){
-            const start = i * chunkSize;
-            const end = Math.min(start + chunkSize, this.fileQueue.length);
-            const chunk = this.fileQueue.slice(start, end);
-            if (chunk.length > 0) {
-                workers.push(this.processChunk(chunk, i));
-            }
-        }
-        await Promise.all(workers);
-    }
-    async processChunk(files, workerId) {
-        for (const file of files){
-            try {
-                await this.copyFile(file);
-                this.copiedFiles.add(file.path);
-                this.reportProgress(this.copiedFiles.size);
-            } catch (error) {
-                this.errors.push({
-                    file: file.path,
-                    error: error instanceof Error ? error.message : String(error),
-                    phase: 'write'
-                });
-            }
-        }
-    }
-    async copyFile(file) {
-        const destPath = path.join(this.options.destination, file.relativePath);
-        if (this.options.dryRun) {
-            logger.info(`[DRY RUN] Would copy ${file.path} to ${destPath}`);
-            return;
-        }
-        // Check for conflicts
-        const destExists = await this.fileExists(destPath);
-        if (destExists) {
-            switch(this.options.conflictResolution){
-                case 'skip':
-                    logger.info(`Skipping existing file: ${destPath}`);
-                    return;
-                case 'backup':
-                    await this.backupFile(destPath);
-                    break;
-                case 'merge':
-                    await this.mergeFiles(file.path, destPath);
-                    return;
-                case 'overwrite':
-                    break;
-            }
-        }
-        // Calculate source hash if verification is enabled
-        if (this.options.verify) {
-            file.hash = await this.calculateFileHash(file.path);
-        }
-        // Copy the file
-        await fs.copyFile(file.path, destPath);
-        // Preserve permissions if requested
-        if (this.options.preservePermissions && file.permissions) {
-            await fs.chmod(destPath, file.permissions);
-        }
-        // Add to rollback stack
-        this.rollbackStack.push(async ()=>{
-            if (destExists && this.backupMap.has(destPath)) {
-                // Restore from backup
-                const backupPath = this.backupMap.get(destPath);
-                await fs.copyFile(backupPath, destPath);
-            } else {
-                // Remove the copied file
-                await fs.unlink(destPath);
-            }
-        });
-        this.copiedFiles.add(file.path);
-    }
-    async backupFile(filePath) {
-        const backupDir = path.join(this.options.destination, '.prompt-backups');
-        await fs.mkdir(backupDir, {
-            recursive: true
-        });
-        const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
-        const backupName = `${path.basename(filePath)}.${timestamp}.bak`;
-        const backupPath = path.join(backupDir, backupName);
-        await fs.copyFile(filePath, backupPath);
-        this.backupMap.set(filePath, backupPath);
-    }
-    async mergeFiles(sourcePath, destPath) {
-        // Simple merge strategy: append source to destination with separator
-        const sourceContent = await fs.readFile(sourcePath, 'utf-8');
-        const destContent = await fs.readFile(destPath, 'utf-8');
-        const separator = '\n\n--- MERGED CONTENT ---\n\n';
-        const mergedContent = destContent + separator + sourceContent;
-        await this.backupFile(destPath);
-        await fs.writeFile(destPath, mergedContent, 'utf-8');
-    }
-    async verifyFiles() {
-        logger.info('Verifying copied files...');
-        for (const file of this.fileQueue){
-            if (!this.copiedFiles.has(file.path)) continue;
-            try {
-                const destPath = path.join(this.options.destination, file.relativePath);
-                // Verify file exists
-                if (!await this.fileExists(destPath)) {
-                    throw new Error('Destination file not found');
-                }
-                // Verify size
-                const destStats = await fs.stat(destPath);
-                const sourceStats = await fs.stat(file.path);
-                if (destStats.size !== sourceStats.size) {
-                    throw new Error(`Size mismatch: ${destStats.size} != ${sourceStats.size}`);
-                }
-                // Verify hash if available
-                if (file.hash) {
-                    const destHash = await this.calculateFileHash(destPath);
-                    if (destHash !== file.hash) {
-                        throw new Error(`Hash mismatch: ${destHash} != ${file.hash}`);
-                    }
-                }
-            } catch (error) {
-                this.errors.push({
-                    file: file.path,
-                    error: error instanceof Error ? error.message : String(error),
-                    phase: 'verify'
-                });
-            }
-        }
-    }
-    async calculateFileHash(filePath) {
-        const content = await fs.readFile(filePath);
-        return createHash('sha256').update(content).digest('hex');
-    }
-    async fileExists(filePath) {
-        try {
-            await fs.access(filePath);
-            return true;
-        } catch  {
-            return false;
-        }
-    }
-    async createBackupManifest() {
-        const manifestPath = path.join(this.options.destination, '.prompt-backups', `manifest-${Date.now()}.json`);
-        const manifest = {
-            timestamp: new Date().toISOString(),
-            source: this.options.source,
-            destination: this.options.destination,
-            backups: Array.from(this.backupMap.entries()).map(([original, backup])=>({
-                    original,
-                    backup
-                }))
-        };
-        await fs.writeFile(manifestPath, JSON.stringify(manifest, null, 2));
-        return manifestPath;
-    }
-    async rollback() {
-        logger.warn('Rolling back changes...');
-        // Execute rollback operations in reverse order
-        for(let i = this.rollbackStack.length - 1; i >= 0; i--){
-            try {
-                await this.rollbackStack[i]();
-            } catch (error) {
-                logger.error(`Rollback operation ${i} failed:`, error);
-            }
-        }
-        // Clean up backup directory if empty
-        try {
-            const backupDir = path.join(this.options.destination, '.prompt-backups');
-            const entries = await fs.readdir(backupDir);
-            if (entries.length === 0) {
-                await fs.rmdir(backupDir);
-            }
-        } catch  {
-        // Ignore cleanup errors
-        }
-    }
-    reportProgress(completed) {
-        const progress = {
-            total: this.fileQueue.length,
-            completed,
-            failed: this.errors.length,
-            skipped: this.fileQueue.length - completed - this.errors.length,
-            percentage: Math.round(completed / this.fileQueue.length * 100)
-        };
-        this.emit('progress', progress);
-        this.options.progressCallback(progress);
-    }
-    // Utility method to restore from backup
-    async restoreFromBackup(manifestPath) {
-        const manifest = JSON.parse(await fs.readFile(manifestPath, 'utf-8'));
-        for (const { original, backup } of manifest.backups){
-            try {
-                await fs.copyFile(backup, original);
-                logger.info(`Restored ${original} from ${backup}`);
-            } catch (error) {
-                logger.error(`Failed to restore ${original}:`, error);
-            }
-        }
-    }
-    constructor(options){
-        super(), _define_property(this, "options", void 0), _define_property(this, "fileQueue", []), _define_property(this, "copiedFiles", new Set()), _define_property(this, "errors", []), _define_property(this, "backupMap", new Map()), _define_property(this, "rollbackStack", []);
-        this.options = {
-            ...options,
-            backup: options.backup ?? true,
-            overwrite: options.overwrite ?? false,
-            verify: options.verify ?? true,
-            preservePermissions: options.preservePermissions ?? true,
-            excludePatterns: options.excludePatterns ?? [],
-            includePatterns: options.includePatterns ?? [
-                '*.md',
-                '*.txt',
-                '*.prompt',
-                '*.prompts'
-            ],
-            parallel: options.parallel ?? true,
-            maxWorkers: options.maxWorkers ?? 4,
-            dryRun: options.dryRun ?? false,
-            conflictResolution: options.conflictResolution ?? 'backup',
-            progressCallback: options.progressCallback ?? (()=>{})
-        };
-    }
-}
-// Export convenience function
-export async function copyPrompts(options) {
-    const copier = new PromptCopier(options);
-    return copier.copy();
-}

package/dist/src/swarm/prompt-manager.js

@@ -1,295 +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 path from "path";
-import { EventEmitter } from "events";
-import { copyPromptsEnhanced } from "./prompt-copier-enhanced.js";
-import { PromptConfigManager, PromptPathResolver, PromptValidator } from "./prompt-utils.js";
-import { logger } from "../core/logger.js";
-export class PromptManager extends EventEmitter {
-    async initialize() {
-        logger.info('Initializing PromptManager...');
-        // Load configuration
-        await this.configManager.loadConfig();
-        // Auto-discover prompt directories if enabled
-        if (this.options.autoDiscovery) {
-            const discovered = await this.pathResolver.discoverPromptDirectories();
-            if (discovered.length > 0) {
-                logger.info(`Auto-discovered ${discovered.length} prompt directories`);
-                // Update config with discovered directories
-                const config = this.configManager.getConfig();
-                const uniqueDirs = Array.from(new Set([
-                    ...config.sourceDirectories,
-                    ...discovered.map((dir)=>path.relative(this.options.basePath, dir))
-                ]));
-                await this.configManager.saveConfig({
-                    sourceDirectories: uniqueDirs
-                });
-            }
-        }
-        this.emit('initialized');
-    }
-    async copyPrompts(options = {}) {
-        const config = this.configManager.getConfig();
-        const profile = this.options.defaultProfile;
-        // Resolve paths
-        const resolved = this.pathResolver.resolvePaths(config.sourceDirectories, config.destinationDirectory);
-        if (resolved.sources.length === 0) {
-            throw new Error('No valid source directories found');
-        }
-        // Build copy options
-        const copyOptions = {
-            source: resolved.sources[0],
-            destination: resolved.destination,
-            ...this.configManager.getProfile(profile),
-            ...options
-        };
-        logger.info('Starting prompt copy operation', {
-            source: copyOptions.source,
-            destination: copyOptions.destination,
-            profile
-        });
-        this.emit('copyStart', copyOptions);
-        try {
-            const result = await (copyOptions.parallel ? copyPromptsEnhanced(copyOptions) : copyPrompts(copyOptions));
-            this.emit('copyComplete', result);
-            return result;
-        } catch (error) {
-            this.emit('copyError', error);
-            throw error;
-        }
-    }
-    async copyFromMultipleSources(options = {}) {
-        const config = this.configManager.getConfig();
-        const resolved = this.pathResolver.resolvePaths(config.sourceDirectories, config.destinationDirectory);
-        const results = [];
-        for (const source of resolved.sources){
-            try {
-                const copyOptions = {
-                    source,
-                    destination: resolved.destination,
-                    ...this.configManager.getProfile(this.options.defaultProfile),
-                    ...options
-                };
-                logger.info(`Copying from source: ${source}`);
-                const result = await copyPrompts(copyOptions);
-                results.push(result);
-                this.emit('sourceComplete', {
-                    source,
-                    result
-                });
-            } catch (error) {
-                logger.error(`Failed to copy from ${source}:`, error);
-                this.emit('sourceError', {
-                    source,
-                    error
-                });
-                // Add error result
-                results.push({
-                    success: false,
-                    totalFiles: 0,
-                    copiedFiles: 0,
-                    failedFiles: 0,
-                    skippedFiles: 0,
-                    errors: [
-                        {
-                            file: source,
-                            error: error instanceof Error ? error.message : String(error),
-                            phase: 'read'
-                        }
-                    ],
-                    duration: 0
-                });
-            }
-        }
-        return results;
-    }
-    async validatePrompts(sourcePath) {
-        const config = this.configManager.getConfig();
-        const sources = sourcePath ? [
-            sourcePath
-        ] : config.sourceDirectories;
-        const resolved = this.pathResolver.resolvePaths(sources, config.destinationDirectory);
-        let totalFiles = 0;
-        let validFiles = 0;
-        let invalidFiles = 0;
-        const issues = [];
-        for (const source of resolved.sources){
-            await this.validateDirectory(source, issues);
-        }
-        totalFiles = issues.length;
-        validFiles = issues.filter((issue)=>issue.issues.length === 0).length;
-        invalidFiles = totalFiles - validFiles;
-        const report = {
-            totalFiles,
-            validFiles,
-            invalidFiles,
-            issues: issues.filter((issue)=>issue.issues.length > 0)
-        };
-        this.emit('validationComplete', report);
-        return report;
-    }
-    async validateDirectory(dirPath, issues) {
-        const fs = require('fs').promises;
-        try {
-            const entries = await fs.readdir(dirPath, {
-                withFileTypes: true
-            });
-            for (const entry of entries){
-                const fullPath = path.join(dirPath, entry.name);
-                if (entry.isFile() && this.isPromptFile(entry.name)) {
-                    const result = await PromptValidator.validatePromptFile(fullPath);
-                    issues.push({
-                        file: fullPath,
-                        issues: result.issues,
-                        metadata: result.metadata
-                    });
-                } else if (entry.isDirectory()) {
-                    await this.validateDirectory(fullPath, issues);
-                }
-            }
-        } catch (error) {
-            logger.error(`Failed to validate directory ${dirPath}:`, error);
-        }
-    }
-    isPromptFile(fileName) {
-        const config = this.configManager.getConfig();
-        const patterns = config.defaultOptions.includePatterns;
-        return patterns.some((pattern)=>{
-            const regex = pattern.replace(/\./g, '\\.').replace(/\*/g, '.*');
-            return new RegExp(regex).test(fileName);
-        });
-    }
-    async syncPrompts(options = {}) {
-        const config = this.configManager.getConfig();
-        const resolved = this.pathResolver.resolvePaths(config.sourceDirectories, config.destinationDirectory);
-        const syncOptions = {
-            bidirectional: false,
-            deleteOrphaned: false,
-            compareHashes: true,
-            incrementalOnly: true,
-            ...options
-        };
-        // Forward sync (source to destination)
-        const forwardResult = await this.performIncrementalSync(resolved.sources[0], resolved.destination, syncOptions);
-        let backwardResult;
-        // Backward sync if bidirectional
-        if (syncOptions.bidirectional) {
-            backwardResult = await this.performIncrementalSync(resolved.destination, resolved.sources[0], syncOptions);
-        }
-        return {
-            forward: forwardResult,
-            backward: backwardResult
-        };
-    }
-    async performIncrementalSync(source, destination, options) {
-        // This would implement incremental sync logic
-        // For now, we'll use the regular copy with overwrite
-        return copyPrompts({
-            source,
-            destination,
-            conflictResolution: 'overwrite',
-            verify: options.compareHashes
-        });
-    }
-    async generateReport() {
-        const config = this.configManager.getConfig();
-        const resolved = this.pathResolver.resolvePaths(config.sourceDirectories, config.destinationDirectory);
-        // Analyze sources
-        const sources = await Promise.all(resolved.sources.map(async (sourcePath)=>{
-            try {
-                const fs = require('fs').promises;
-                const stats = await fs.stat(sourcePath);
-                if (!stats.isDirectory()) {
-                    return {
-                        path: sourcePath,
-                        exists: false
-                    };
-                }
-                // Count files and calculate total size
-                let fileCount = 0;
-                let totalSize = 0;
-                const scanDir = async (dir)=>{
-                    const entries = await fs.readdir(dir, {
-                        withFileTypes: true
-                    });
-                    for (const entry of entries){
-                        const fullPath = path.join(dir, entry.name);
-                        if (entry.isFile() && this.isPromptFile(entry.name)) {
-                            const fileStats = await fs.stat(fullPath);
-                            fileCount++;
-                            totalSize += fileStats.size;
-                        } else if (entry.isDirectory()) {
-                            await scanDir(fullPath);
-                        }
-                    }
-                };
-                await scanDir(sourcePath);
-                return {
-                    path: sourcePath,
-                    exists: true,
-                    fileCount,
-                    totalSize
-                };
-            } catch  {
-                return {
-                    path: sourcePath,
-                    exists: false
-                };
-            }
-        }));
-        return {
-            configuration: config,
-            sources
-        };
-    }
-    // Utility methods
-    getConfig() {
-        return this.configManager.getConfig();
-    }
-    async updateConfig(updates) {
-        await this.configManager.saveConfig(updates);
-    }
-    getProfiles() {
-        return this.configManager.listProfiles();
-    }
-    getProfile(name) {
-        return this.configManager.getProfile(name);
-    }
-    async discoverPromptDirectories() {
-        return this.pathResolver.discoverPromptDirectories();
-    }
-    constructor(options = {}){
-        super(), _define_property(this, "configManager", void 0), _define_property(this, "pathResolver", void 0), _define_property(this, "options", void 0);
-        this.options = {
-            configPath: options.configPath || '.prompt-config.json',
-            basePath: options.basePath || process.cwd(),
-            autoDiscovery: options.autoDiscovery ?? true,
-            defaultProfile: options.defaultProfile || 'sparc'
-        };
-        this.configManager = new PromptConfigManager(path.resolve(this.options.basePath, this.options.configPath));
-        this.pathResolver = new PromptPathResolver(this.options.basePath);
-    }
-}
-// Export factory function
-export function createPromptManager(options) {
-    return new PromptManager(options);
-}
-// Export singleton instance
-let defaultManager = null;
-export function getDefaultPromptManager() {
-    if (!defaultManager) {
-        defaultManager = new PromptManager();
-    }
-    return defaultManager;
-}