claude-flow-novice 2.0.3 → 2.0.4

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

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

@@ -0,0 +1,295 @@
+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;
+}