claude-flow-novice 2.0.3 → 2.0.4

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

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

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

@@ -0,0 +1,344 @@
+import * as fs from "node:fs/promises";
+import * as path from "path";
+import * as os from "os";
+import { copyPrompts } from "../prompt-copier.js";
+import { copyPromptsEnhanced } from "../prompt-copier-enhanced.js";
+import { PromptConfigManager, PromptValidator } from "../prompt-utils.js";
+describe('PromptCopier', ()=>{
+    let tempDir;
+    let sourceDir;
+    let destDir;
+    beforeEach(async ()=>{
+        tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'prompt-test-'));
+        sourceDir = path.join(tempDir, 'source');
+        destDir = path.join(tempDir, 'dest');
+        await fs.mkdir(sourceDir, {
+            recursive: true
+        });
+        await fs.mkdir(destDir, {
+            recursive: true
+        });
+        // Create test files
+        await createTestFiles();
+    });
+    afterEach(async ()=>{
+        await fs.rm(tempDir, {
+            recursive: true,
+            force: true
+        });
+    });
+    async function createTestFiles() {
+        const testFiles = [
+            {
+                path: 'test1.md',
+                content: '# Test Prompt 1\nThis is a test prompt.'
+            },
+            {
+                path: 'test2.txt',
+                content: 'Test prompt content'
+            },
+            {
+                path: 'subdir/test3.md',
+                content: '## Nested Prompt\nNested content'
+            },
+            {
+                path: 'large.md',
+                content: 'Large content\n'.repeat(1000)
+            },
+            {
+                path: 'empty.md',
+                content: ''
+            },
+            {
+                path: 'rules.md',
+                content: '# Rules\nYou are an AI assistant.'
+            }
+        ];
+        for (const file of testFiles){
+            const filePath = path.join(sourceDir, file.path);
+            const dir = path.dirname(filePath);
+            await fs.mkdir(dir, {
+                recursive: true
+            });
+            await fs.writeFile(filePath, file.content);
+        }
+    }
+    describe('Basic copying functionality', ()=>{
+        test('should copy all matching files', async ()=>{
+            const result = await copyPrompts({
+                source: sourceDir,
+                destination: destDir
+            });
+            expect(result.success).toBe(true);
+            expect(result.copiedFiles).toBe(6);
+            expect(result.failedFiles).toBe(0);
+            // Verify files exist
+            const destFiles = await fs.readdir(destDir, {
+                recursive: true
+            });
+            expect(destFiles).toHaveLength(6);
+        });
+        test('should respect include patterns', async ()=>{
+            const result = await copyPrompts({
+                source: sourceDir,
+                destination: destDir,
+                includePatterns: [
+                    '*.md'
+                ]
+            });
+            expect(result.success).toBe(true);
+            expect(result.copiedFiles).toBe(5); // Only .md files
+        });
+        test('should respect exclude patterns', async ()=>{
+            const result = await copyPrompts({
+                source: sourceDir,
+                destination: destDir,
+                excludePatterns: [
+                    '**/subdir/**'
+                ]
+            });
+            expect(result.success).toBe(true);
+            expect(result.copiedFiles).toBe(5); // Excluding subdir files
+        });
+    });
+    describe('Conflict resolution', ()=>{
+        test('should skip existing files when conflict resolution is skip', async ()=>{
+            // Create existing file
+            await fs.writeFile(path.join(destDir, 'test1.md'), 'Existing content');
+            const result = await copyPrompts({
+                source: sourceDir,
+                destination: destDir,
+                conflictResolution: 'skip'
+            });
+            expect(result.success).toBe(true);
+            expect(result.skippedFiles).toBeGreaterThan(0);
+            // Verify original content preserved
+            const content = await fs.readFile(path.join(destDir, 'test1.md'), 'utf-8');
+            expect(content).toBe('Existing content');
+        });
+        test('should backup existing files when conflict resolution is backup', async ()=>{
+            // Create existing file
+            await fs.writeFile(path.join(destDir, 'test1.md'), 'Existing content');
+            const result = await copyPrompts({
+                source: sourceDir,
+                destination: destDir,
+                conflictResolution: 'backup'
+            });
+            expect(result.success).toBe(true);
+            expect(result.backupLocation).toBeDefined();
+            // Verify backup directory exists
+            const backupDir = path.join(destDir, '.prompt-backups');
+            const backupExists = await fs.access(backupDir).then(()=>true).catch(()=>false);
+            expect(backupExists).toBe(true);
+        });
+        test('should merge files when conflict resolution is merge', async ()=>{
+            // Create existing file
+            await fs.writeFile(path.join(destDir, 'test1.md'), 'Existing content');
+            const result = await copyPrompts({
+                source: sourceDir,
+                destination: destDir,
+                conflictResolution: 'merge'
+            });
+            expect(result.success).toBe(true);
+            // Verify merged content
+            const content = await fs.readFile(path.join(destDir, 'test1.md'), 'utf-8');
+            expect(content).toContain('Existing content');
+            expect(content).toContain('MERGED CONTENT');
+            expect(content).toContain('# Test Prompt 1');
+        });
+    });
+    describe('Verification', ()=>{
+        test('should verify copied files when verification is enabled', async ()=>{
+            const result = await copyPrompts({
+                source: sourceDir,
+                destination: destDir,
+                verify: true
+            });
+            expect(result.success).toBe(true);
+            expect(result.failedFiles).toBe(0);
+        });
+        test('should detect verification failures', async ()=>{
+            // Mock fs.stat to simulate size mismatch
+            const originalStat = fs.stat;
+            jest.spyOn(fs, 'stat').mockImplementation(async (filePath)=>{
+                const stats = await originalStat(filePath);
+                if (filePath.includes('dest') && filePath.includes('test1.md')) {
+                    return {
+                        ...stats,
+                        size: stats.size + 1
+                    };
+                }
+                return stats;
+            });
+            const result = await copyPrompts({
+                source: sourceDir,
+                destination: destDir,
+                verify: true
+            });
+            expect(result.errors.length).toBeGreaterThan(0);
+            expect(result.errors[0].phase).toBe('verify');
+            fs.stat.mockRestore();
+        });
+    });
+    describe('Dry run mode', ()=>{
+        test('should not create files in dry run mode', async ()=>{
+            const result = await copyPrompts({
+                source: sourceDir,
+                destination: destDir,
+                dryRun: true
+            });
+            expect(result.success).toBe(true);
+            expect(result.totalFiles).toBe(6);
+            // Verify no files were actually copied
+            const destFiles = await fs.readdir(destDir);
+            expect(destFiles).toHaveLength(0);
+        });
+    });
+    describe('Progress reporting', ()=>{
+        test('should report progress during copy', async ()=>{
+            const progressUpdates = [];
+            await copyPrompts({
+                source: sourceDir,
+                destination: destDir,
+                progressCallback: (progress)=>{
+                    progressUpdates.push(progress);
+                }
+            });
+            expect(progressUpdates.length).toBeGreaterThan(0);
+            expect(progressUpdates[progressUpdates.length - 1].percentage).toBe(100);
+        });
+    });
+});
+describe('EnhancedPromptCopier', ()=>{
+    let tempDir;
+    let sourceDir;
+    let destDir;
+    beforeEach(async ()=>{
+        tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'enhanced-test-'));
+        sourceDir = path.join(tempDir, 'source');
+        destDir = path.join(tempDir, 'dest');
+        await fs.mkdir(sourceDir, {
+            recursive: true
+        });
+        await fs.mkdir(destDir, {
+            recursive: true
+        });
+        // Create test files
+        for(let i = 0; i < 20; i++){
+            await fs.writeFile(path.join(sourceDir, `test${i}.md`), `# Test ${i}\nContent for test ${i}`);
+        }
+    });
+    afterEach(async ()=>{
+        await fs.rm(tempDir, {
+            recursive: true,
+            force: true
+        });
+    });
+    test('should copy files using worker threads', async ()=>{
+        const result = await copyPromptsEnhanced({
+            source: sourceDir,
+            destination: destDir,
+            parallel: true,
+            maxWorkers: 4
+        });
+        expect(result.success).toBe(true);
+        expect(result.copiedFiles).toBe(20);
+        expect(result.failedFiles).toBe(0);
+        // Verify all files were copied
+        const destFiles = await fs.readdir(destDir);
+        expect(destFiles).toHaveLength(20);
+    }, 10000);
+});
+describe('PromptConfigManager', ()=>{
+    let tempDir;
+    let configPath;
+    beforeEach(async ()=>{
+        tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'config-test-'));
+        configPath = path.join(tempDir, '.prompt-config.json');
+    });
+    afterEach(async ()=>{
+        await fs.rm(tempDir, {
+            recursive: true,
+            force: true
+        });
+    });
+    test('should load default config when file does not exist', async ()=>{
+        const manager = new PromptConfigManager(configPath);
+        const config = await manager.loadConfig();
+        expect(config).toBeDefined();
+        expect(config.defaultOptions).toBeDefined();
+        expect(config.profiles).toBeDefined();
+    });
+    test('should save and load custom config', async ()=>{
+        const manager = new PromptConfigManager(configPath);
+        await manager.saveConfig({
+            destinationDirectory: './custom-prompts'
+        });
+        const config = await manager.loadConfig();
+        expect(config.destinationDirectory).toBe('./custom-prompts');
+    });
+    test('should get profile options', async ()=>{
+        const manager = new PromptConfigManager(configPath);
+        await manager.loadConfig();
+        const sparcProfile = manager.getProfile('sparc');
+        expect(sparcProfile).toBeDefined();
+        expect(sparcProfile.includePatterns).toContain('*.md');
+    });
+    test('should list available profiles', async ()=>{
+        const manager = new PromptConfigManager(configPath);
+        await manager.loadConfig();
+        const profiles = manager.listProfiles();
+        expect(profiles).toContain('sparc');
+        expect(profiles).toContain('templates');
+        expect(profiles).toContain('safe');
+        expect(profiles).toContain('fast');
+    });
+});
+describe('PromptValidator', ()=>{
+    let tempDir;
+    beforeEach(async ()=>{
+        tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'validator-test-'));
+    });
+    afterEach(async ()=>{
+        await fs.rm(tempDir, {
+            recursive: true,
+            force: true
+        });
+    });
+    test('should validate valid prompt file', async ()=>{
+        const filePath = path.join(tempDir, 'valid.md');
+        await fs.writeFile(filePath, '# Test Prompt\nYou are an AI assistant.');
+        const result = await PromptValidator.validatePromptFile(filePath);
+        expect(result.valid).toBe(true);
+        expect(result.issues).toHaveLength(0);
+    });
+    test('should detect empty files', async ()=>{
+        const filePath = path.join(tempDir, 'empty.md');
+        await fs.writeFile(filePath, '');
+        const result = await PromptValidator.validatePromptFile(filePath);
+        expect(result.valid).toBe(false);
+        expect(result.issues).toContain('File is empty');
+    });
+    test('should extract front matter metadata', async ()=>{
+        const filePath = path.join(tempDir, 'with-metadata.md');
+        const content = `---
+title: Test Prompt
+version: 1.0
+---
+
+# Test Prompt
+Content here`;
+        await fs.writeFile(filePath, content);
+        const result = await PromptValidator.validatePromptFile(filePath);
+        expect(result.metadata).toBeDefined();
+        expect(result.metadata.title).toBe('Test Prompt');
+        expect(result.metadata.version).toBe('1.0');
+    });
+    test('should warn about large files', async ()=>{
+        const filePath = path.join(tempDir, 'large.md');
+        const largeContent = '# Large Prompt\n' + 'x'.repeat(200 * 1024); // 200KB
+        await fs.writeFile(filePath, largeContent);
+        const result = await PromptValidator.validatePromptFile(filePath);
+        expect(result.issues).toContain('File is unusually large for a prompt');
+    });
+});