claude-flow-novice 1.0.0

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

@@ -0,0 +1,376 @@
+import * as fs from '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 {
+    options;
+    fileQueue = [];
+    copiedFiles = new Set();
+    errors = [];
+    backupMap = new Map();
+    rollbackStack = [];
+    constructor(options){
+        super();
+        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 ?? (()=>{})
+        };
+    }
+    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);
+            }
+        }
+    }
+}
+// Export convenience function
+export async function copyPrompts(options) {
+    const copier = new PromptCopier(options);
+    return copier.copy();
+}
+
+//# sourceMappingURL=prompt-copier.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/swarm/prompt-copier.ts"],"names":["fs","path","createHash","EventEmitter","logger","PromptCopier","options","fileQueue","copiedFiles","Set","errors","backupMap","Map","rollbackStack","backup","overwrite","verify","preservePermissions","excludePatterns","includePatterns","parallel","maxWorkers","dryRun","conflictResolution","progressCallback","copy","startTime","Date","now","info","discoverFiles","length","success","totalFiles","failedFiles","skippedFiles","duration","ensureDestinationDirectories","copyFilesParallel","copyFilesSequential","verifyFiles","result","size","backupLocation","createBackupManifest","error","rollback","sourceStats","stat","source","isDirectory","Error","scanDirectory","sort","a","b","dirPath","relativePath","entries","readdir","withFileTypes","entry","fullPath","join","name","relPath","isFile","shouldIncludeFile","stats","push","permissions","mode","filePath","pattern","matchPattern","regex","replace","RegExp","test","directories","file","destDir","dirname","destination","add","sortedDirs","Array","from","dir","mkdir","recursive","completed","copyFile","reportProgress","message","String","phase","workerCount","Math","min","chunkSize","ceil","workers","i","start","end","chunk","slice","processChunk","Promise","all","files","workerId","destPath","destExists","fileExists","backupFile","mergeFiles","hash","calculateFileHash","chmod","has","backupPath","get","unlink","backupDir","timestamp","toISOString","backupName","basename","set","sourcePath","sourceContent","readFile","destContent","separator","mergedContent","writeFile","destStats","destHash","content","update","digest","access","manifestPath","manifest","backups","map","original","JSON","stringify","warn","rmdir","progress","total","failed","skipped","percentage","round","emit","restoreFromBackup","parse","copyPrompts","copier"],"mappings":"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"}

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

@@ -0,0 +1,287 @@
+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 {
+    configManager;
+    pathResolver;
+    options;
+    constructor(options = {}){
+        super();
+        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);
+    }
+    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();
+    }
+}
+// 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;
+}
+
+//# sourceMappingURL=prompt-manager.js.map