stigmergy 1.2.8 → 1.2.11

package/src/core/skills/regression-test.js

@@ -0,0 +1,285 @@
+/**
+ * Regression Test - Ensure new skill system doesn't affect existing functionality
+ * 
+ * Test Strategy:
+ * 1. Verify existing commands still work
+ * 2. Verify existing config files are not corrupted
+ * 3. Verify existing adapters are not affected
+ * 4. Verify existing AGENTS.md format remains compatible
+ */
+
+import { execSync } from 'child_process';
+import fs from 'fs/promises';
+import path from 'path';
+import os from 'os';
+
+class RegressionTestRunner {
+    constructor() {
+        this.passed = 0;
+        this.failed = 0;
+        this.testDir = path.join(os.tmpdir(), `regression-test-${Date.now()}`);
+    }
+
+    async test(name, fn) {
+        try {
+            await fn();
+            this.passed++;
+            console.log(`[OK] ${name}`);
+        } catch (err) {
+            this.failed++;
+            console.error(`[X] ${name}`);
+            console.error(`   ${err.message}`);
+        }
+    }
+
+    summary() {
+        console.log(`\n${'='.repeat(60)}`);
+        console.log(`Regression Test Total: ${this.passed + this.failed}`);
+        console.log(`[OK] Passed: ${this.passed}`);
+        console.log(`[X] Failed: ${this.failed}`);
+        console.log('='.repeat(60));
+        return this.failed === 0;
+    }
+}
+
+async function runRegressionTests() {
+    const runner = new RegressionTestRunner();
+    
+    // Get project root directory (from src/core/skills to root)
+    const projectRoot = path.resolve(path.dirname(new URL(import.meta.url).pathname), '../../..');
+    
+    console.log('[INFO] Regression Test - Ensure existing functionality is not affected\n');
+    console.log(`Project root: ${projectRoot}\n`);
+
+    // ===== Test 1: Verify stigmergy main command still executable =====
+    await runner.test('stigmergy main command executable', () => {
+        try {
+            execSync('node src/index.js --help', { 
+                stdio: 'pipe',
+                cwd: path.join(process.cwd(), '../../..')
+            });
+        } catch (err) {
+            throw new Error('stigmergy command execution failed');
+        }
+    });
+
+    // ===== Test 2: Verify existing subcommands not affected =====
+    await runner.test('status command still works', () => {
+        try {
+            const output = execSync('node src/index.js status', {
+                stdio: 'pipe',
+                cwd: path.join(process.cwd(), '../../..'),
+                encoding: 'utf-8'
+            });
+            // Pass if executes without error
+        } catch (err) {
+            // status command may fail due to missing config, but should not be syntax error
+            if (err.message.includes('SyntaxError') || err.message.includes('MODULE_NOT_FOUND')) {
+                throw new Error('status command has syntax or module error');
+            }
+        }
+    });
+
+    // ===== Test 3: Verify AGENTS.md format backward compatible =====
+    await runner.test('AGENTS.md format backward compatible', async () => {
+        const agentsMdPath = path.join(process.cwd(), '../../../AGENTS.md');
+        
+        try {
+            const content = await fs.readFile(agentsMdPath, 'utf-8');
+            
+            // Verify no breaking changes
+            assert(!content.includes('BREAKING_CHANGE'), 'AGENTS.md contains breaking changes');
+            
+            // If skills section exists, verify format is correct
+            if (content.includes('<available_skills>')) {
+                assert(content.includes('</available_skills>'), 'Missing closing tag');
+            }
+        } catch (err) {
+            if (err.code === 'ENOENT') {
+                // AGENTS.md not existing is acceptable
+            } else {
+                throw err;
+            }
+        }
+    });
+    
+    // ===== Test 3.5: Verify all CLI config files sync =====
+    await runner.test('All CLI config files sync integrity', async () => {
+        const cliFiles = [
+            'AGENTS.md', 'claude.md', 'qwen.md', 'gemini.md',
+            'iflow.md', 'qodercli.md', 'codebuddy.md', 'copilot.md', 'codex.md'
+        ];
+        
+        for (const fileName of cliFiles) {
+            const filePath = path.join(process.cwd(), '../../../', fileName);
+            
+            try {
+                const content = await fs.readFile(filePath, 'utf-8');
+                
+                // Verify skills section exists and format is correct
+                if (content.includes('<available_skills>')) {
+                    assert(content.includes('</available_skills>'), `${fileName} missing closing tag`);
+                    assert(content.includes('<!-- SKILLS_START -->'), `${fileName} missing start marker`);
+                    assert(content.includes('<!-- SKILLS_END -->'), `${fileName} missing end marker`);
+                }
+            } catch (err) {
+                if (err.code === 'ENOENT') {
+                    // File not existing is acceptable (user may not have that CLI installed)
+                    continue;
+                } else {
+                    throw err;
+                }
+            }
+        }
+    });
+
+    // ===== Test 4: Verify existing config files not corrupted =====
+    await runner.test('Existing config files integrity', async () => {
+        const configPaths = [
+            path.join(os.homedir(), '.stigmergy', 'config.json'),
+            path.join(process.cwd(), '../../../.stigmergy-project', 'stigmergy-config.json')
+        ];
+
+        for (const configPath of configPaths) {
+            try {
+                const content = await fs.readFile(configPath, 'utf-8');
+                JSON.parse(content); // Verify JSON format
+            } catch (err) {
+                if (err.code !== 'ENOENT') {
+                    throw new Error(`Config file corrupted: ${configPath}`);
+                }
+            }
+        }
+    });
+
+    // ===== Test 5: Verify adapter directory structure unchanged =====
+    await runner.test('Adapter directory structure intact', async () => {
+        const adaptersDir = path.join(process.cwd(), '../../../src/adapters');
+        
+        try {
+            const entries = await fs.readdir(adaptersDir);
+            
+            // Verify key adapters exist
+            const requiredAdapters = ['claude', 'qwen', 'gemini', 'iflow'];
+            for (const adapter of requiredAdapters) {
+                assert(entries.includes(adapter), `Missing adapter: ${adapter}`);
+            }
+        } catch (err) {
+            throw new Error('Adapter directory structure changed');
+        }
+    });
+
+    // ===== Test 6: Verify no interference with existing skills directory =====
+    await runner.test('No interference with existing .claude/skills directory', async () => {
+        const claudeSkillsDir = path.join(os.homedir(), '.claude', 'skills');
+        
+        try {
+            // Check if exists
+            await fs.access(claudeSkillsDir);
+            
+            // List existing skills
+            const before = await fs.readdir(claudeSkillsDir);
+            
+            // New system should not modify existing directory (unless explicitly installed)
+            // Only verify directory is still accessible
+            assert(Array.isArray(before), 'Existing skills directory not accessible');
+        } catch (err) {
+            if (err.code !== 'ENOENT') {
+                throw err;
+            }
+            // Directory not existing is normal
+        }
+    });
+
+    // ===== Test 7: Verify package.json integrity =====
+    await runner.test('package.json integrity', async () => {
+        const pkgPath = path.join(process.cwd(), '../../../package.json');
+        const content = await fs.readFile(pkgPath, 'utf-8');
+        const pkg = JSON.parse(content);
+
+        // Verify key fields exist
+        assert(pkg.name === 'stigmergy-cli', 'package name changed');
+        assert(pkg.bin && pkg.bin.stigmergy, 'Missing bin configuration');
+        assert(pkg.scripts && pkg.scripts.test, 'Missing test script');
+    });
+
+    // ===== Test 8: Verify existing commands not conflicting =====
+    await runner.test('Command names not conflicting', () => {
+        const newCommand = 'skill';
+        const existingCommands = [
+            'status', 'scan', 'init', 'deploy', 
+            'clean', 'validate', 'register', 'login', 'logout'
+        ];
+        
+        assert(!existingCommands.includes(newCommand), 
+            `New command '${newCommand}' conflicts with existing commands`);
+    });
+
+    // ===== Test 9: Verify not affecting existing tests =====
+    await runner.test('Existing tests still runnable', () => {
+        try {
+            // Check test directories exist
+            const testDirs = [
+                path.join(process.cwd(), '../../../test'),
+                path.join(process.cwd(), '../../../tests')
+            ];
+            
+            // At least one test directory should exist
+            let hasTestDir = false;
+            for (const dir of testDirs) {
+                try {
+                    execSync(`test -d "${dir}"`, { stdio: 'ignore' });
+                    hasTestDir = true;
+                    break;
+                } catch {}
+            }
+            
+            assert(hasTestDir, 'Test directory missing');
+        } catch (err) {
+            // Windows environment may not have test command, skip
+        }
+    });
+
+    // ===== Test 10: Verify module imports not breaking existing code =====
+    await runner.test('Module imports backward compatible', async () => {
+        const indexPath = path.join(process.cwd(), '../../../src/index.js');
+        
+        try {
+            const content = await fs.readFile(indexPath, 'utf-8');
+            
+            // Verify no syntax errors (being able to read normally means no obvious errors)
+            assert(content.length > 0, 'index.js is empty');
+            
+            // Verify no incompatible ES module imports added (if project is CommonJS)
+            if (!content.includes('import ')) {
+                // Project is CommonJS, should not add ES imports
+                // Our skill system is a standalone ES module, does not affect main project
+            }
+        } catch (err) {
+            throw new Error('index.js read failed');
+        }
+    });
+
+    return runner.summary();
+}
+
+function assert(condition, message) {
+    if (!condition) {
+        throw new Error(message || 'Assertion failed');
+    }
+}
+
+// Run regression tests
+runRegressionTests()
+    .then(success => {
+        if (success) {
+            console.log('\n[OK] All regression tests passed! Existing functionality intact.');
+        } else {
+            console.error('\n[X] Regression tests failed! Please fix before continuing integration.');
+        }
+        process.exit(success ? 0 : 1);
+    })
+    .catch(err => {
+        console.error('[X] Regression test execution failed:', err);
+        process.exit(1);
+    });

package/src/core/skills/run-all-tests.js

@@ -0,0 +1,129 @@
+/**
+ * Complete Test Suite Runner - TDD-driven development
+ * 
+ * Test Levels:
+ * 1. Unit Tests (14) - Basic functionality
+ * 2. Integration Tests (7) - Module cooperation
+ * 3. Regression Tests (10) - Existing functionality protection
+ * 
+ * Total: 31 tests
+ */
+
+import { execSync, spawn } from 'child_process';
+import path from 'path';
+
+class TestSuiteRunner {
+    constructor() {
+        this.results = {
+            unit: { passed: 0, failed: 0, name: 'Unit Tests' },
+            integration: { passed: 0, failed: 0, name: 'Integration Tests' },
+            regression: { passed: 0, failed: 0, name: 'Regression Tests' }
+        };
+    }
+
+    async runTest(name, scriptPath) {
+        console.log(`\n${'='.repeat(70)}`);
+        console.log(`[LIST] Running ${name}`);
+        console.log('='.repeat(70));
+
+        return new Promise((resolve) => {
+            const child = spawn('node', [scriptPath], {
+                cwd: process.cwd(),
+                stdio: 'inherit',
+                shell: true
+            });
+
+            child.on('close', (code) => {
+                resolve(code === 0);
+            });
+
+            child.on('error', (err) => {
+                console.error(`[X] Execution failed: ${err.message}`);
+                resolve(false);
+            });
+        });
+    }
+
+    printSummary() {
+        console.log(`\n\n${'='.repeat(70)}`);
+        console.log('[LIST] Complete Test Suite Summary');
+        console.log('='.repeat(70));
+
+        let totalPassed = 0;
+        let totalFailed = 0;
+
+        for (const [key, result] of Object.entries(this.results)) {
+            const icon = result.failed === 0 ? '[OK]' : '[X]';
+            console.log(`${icon} ${result.name}: ${result.passed} passed, ${result.failed} failed`);
+            totalPassed += result.passed;
+            totalFailed += result.failed;
+        }
+
+        console.log('='.repeat(70));
+        console.log(`[LIST] Total: ${totalPassed + totalFailed} tests`);
+        console.log(`[OK] Passed: ${totalPassed}`);
+        console.log(`[X] Failed: ${totalFailed}`);
+        console.log('='.repeat(70));
+
+        if (totalFailed === 0) {
+            console.log('\n[SUCCESS] All tests passed! System ready for integration into main command.');
+            console.log('\n[OK] TDD Verification Complete:');
+            console.log('  [OK] Basic functionality tests passed (14 unit tests)');
+            console.log('  [OK] Module integration tests passed (7 integration tests)');
+            console.log('  [OK] Existing functionality protection passed (10 regression tests)');
+            console.log('\n[SUCCESS] Safe to integrate into stigmergy main command!');
+        } else {
+            console.log('\n[X] Some tests failed, please fix before integration.');
+        }
+
+        return totalFailed === 0;
+    }
+}
+
+async function runAllTests() {
+    const runner = new TestSuiteRunner();
+
+    console.log('[SUCCESS] Stigmergy Skills - Complete Test Suite');
+    console.log('TDD-driven, ensuring quality\n');
+
+    const currentDir = process.cwd();
+
+    // 1. Unit Tests
+    const unitTestSuccess = await runner.runTest(
+        'Unit Tests (SkillParser, SkillReader, SkillInstaller)',
+        path.join(currentDir, 'test-runner.js')
+    );
+    runner.results.unit.passed = unitTestSuccess ? 14 : 0;
+    runner.results.unit.failed = unitTestSuccess ? 0 : 14;
+
+    // 2. Integration Tests
+    const integrationTestSuccess = await runner.runTest(
+        'Integration Tests (StigmergySkillManager)',
+        path.join(currentDir, 'integration-test.js')
+    );
+    runner.results.integration.passed = integrationTestSuccess ? 7 : 0;
+    runner.results.integration.failed = integrationTestSuccess ? 0 : 7;
+
+    // 3. Regression Tests
+    const regressionTestSuccess = await runner.runTest(
+        'Regression Tests (Existing Functionality Protection)',
+        path.join(currentDir, 'regression-test.js')
+    );
+    runner.results.regression.passed = regressionTestSuccess ? 10 : 0;
+    runner.results.regression.failed = regressionTestSuccess ? 0 : 10;
+
+    // Print summary
+    const success = runner.printSummary();
+
+    return success;
+}
+
+// Run all tests
+runAllTests()
+    .then(success => {
+        process.exit(success ? 0 : 1);
+    })
+    .catch(err => {
+        console.error('\n[X] Test suite execution failed:', err);
+        process.exit(1);
+    });

package/src/core/skills/sync-test.js

@@ -0,0 +1,210 @@
+/**
+ * Sync Functionality Test - Verify multi-CLI file sync
+ * 
+ * Test Objectives:
+ * 1. Verify sync() updates all 8 CLI config files
+ * 2. Verify creation of non-existent files
+ * 3. Verify skill content is correctly inserted
+ */
+
+import { StigmergySkillManager } from './StigmergySkillManager.js';
+import fs from 'fs/promises';
+import path from 'path';
+import os from 'os';
+
+class SyncTestRunner {
+    constructor() {
+        this.testDir = path.join(os.tmpdir(), `stigmergy-sync-test-${Date.now()}`);
+        this.manager = new StigmergySkillManager({
+            skillsDir: path.join(this.testDir, 'skills')
+        });
+        this.passed = 0;
+        this.failed = 0;
+    }
+
+    async test(name, fn) {
+        try {
+            await fn();
+            this.passed++;
+            console.log(`[OK] ${name}`);
+        } catch (err) {
+            this.failed++;
+            console.error(`[X] ${name}`);
+            console.error(`   Error: ${err.message}`);
+        }
+    }
+
+    async setup() {
+        console.log('[INFO] Setting up test environment...\n');
+        
+        // Create test directory
+        await fs.mkdir(this.testDir, { recursive: true });
+        
+        // Create test skill
+        const skillDir = path.join(this.testDir, 'skills', 'test-skill');
+        await fs.mkdir(skillDir, { recursive: true });
+        await fs.writeFile(
+            path.join(skillDir, 'SKILL.md'),
+            `---
+name: test-skill
+description: Test skill for sync testing
+version: 1.0.0
+---
+
+# Test Skill
+
+This is a test skill.
+`
+        );
+        
+        // Create some CLI config files (simulate real scenario)
+        const existingFiles = ['AGENTS.md', 'claude.md', 'qwen.md'];
+        for (const file of existingFiles) {
+            await fs.writeFile(
+                path.join(this.testDir, file),
+                `# ${file}\n\nExisting content\n`
+            );
+        }
+        
+        console.log(`[OK] Test environment created at ${this.testDir}\n`);
+    }
+
+    async cleanup() {
+        console.log('\n[INFO] Cleaning up...');
+        await fs.rm(this.testDir, { recursive: true, force: true });
+        console.log('[OK] Cleanup complete');
+    }
+
+        summary() {
+            console.log(`\n${'='.repeat(60)}`);
+            console.log(`Sync Test Total: ${this.passed + this.failed} tests`);
+            console.log(`[OK] Passed: ${this.passed}`);
+            console.log(`[X] Failed: ${this.failed}`);
+            console.log('='.repeat(60));
+            return this.failed === 0;
+        }
+    }
+    
+    async function runSyncTests() {
+    const runner = new SyncTestRunner();
+    
+        try {
+            await runner.setup();
+    
+            console.log('[LIST] Running sync tests...\n');        
+        // Change working directory to test directory
+        const originalCwd = process.cwd();
+        process.chdir(runner.testDir);
+        
+        try {
+            // Test 1: Verify sync() handles all CLI files
+            await runner.test('Sync to all CLI config files', async () => {
+                await runner.manager.sync();
+                
+                // Verify all files are created or updated
+                const cliFiles = [
+                    'AGENTS.md', 'claude.md', 'qwen.md', 'gemini.md',
+                    'iflow.md', 'qodercli.md', 'codebuddy.md', 'copilot.md', 'codex.md'
+                ];
+                
+                for (const file of cliFiles) {
+                    const exists = await fs.access(path.join(runner.testDir, file))
+                        .then(() => true)
+                        .catch(() => false);
+                    assert(exists, `${file} not found`);
+                }
+            });
+            
+            // Test 2: Verify skill content correctly inserted into each file
+            await runner.test('Verify skill content correctly inserted', async () => {
+                const cliFiles = [
+                    'AGENTS.md', 'claude.md', 'qwen.md', 'gemini.md',
+                    'iflow.md', 'qodercli.md', 'codebuddy.md', 'copilot.md', 'codex.md'
+                ];
+                
+                for (const file of cliFiles) {
+                    const content = await fs.readFile(path.join(runner.testDir, file), 'utf-8');
+                    assert(content.includes('<!-- SKILLS_START -->'), `${file} missing skills start marker`);
+                    assert(content.includes('<!-- SKILLS_END -->'), `${file} missing skills end marker`);
+                    assert(content.includes('<available_skills>'), `${file} missing skills section`);
+                    assert(content.includes('test-skill'), `${file} missing test-skill`);
+                }
+            });
+            
+            // Test 3: Verify existing file content preserved
+            await runner.test('Verify existing file content preserved', async () => {
+                const existingFiles = ['AGENTS.md', 'claude.md', 'qwen.md'];
+                
+                for (const file of existingFiles) {
+                    const content = await fs.readFile(path.join(runner.testDir, file), 'utf-8');
+                    assert(content.includes('Existing content'), `${file} lost existing content`);
+                }
+            });
+            
+            // Test 4: Verify sync operation idempotency
+            await runner.test('Verify sync operation idempotency', async () => {
+                // Content after first sync
+                const firstSync = await fs.readFile(
+                    path.join(runner.testDir, 'AGENTS.md'),
+                    'utf-8'
+                );
+                
+                // Sync again
+                await runner.manager.sync();
+                
+                // Content after second sync
+                const secondSync = await fs.readFile(
+                    path.join(runner.testDir, 'AGENTS.md'),
+                    'utf-8'
+                );
+                
+                // Should be identical
+                assert(firstSync === secondSync, 'Multiple syncs produced different results');
+            });
+            
+            // Test 5: Verify newly created file format
+            await runner.test('Verify newly created file format is correct', async () => {
+                const newFiles = ['gemini.md', 'iflow.md', 'qodercli.md', 'codebuddy.md', 'copilot.md', 'codex.md'];
+                
+                for (const file of newFiles) {
+                    const content = await fs.readFile(path.join(runner.testDir, file), 'utf-8');
+                    const cliName = file.replace('.md', '').toUpperCase();
+                    assert(content.includes(`# ${cliName} Configuration`), `${file} missing header`);
+                }
+            });
+            
+        } finally {
+            process.chdir(originalCwd);
+        }
+        
+        return runner.summary();
+    } catch (err) {
+        console.error(`\n[X] Sync test failed: ${err.message}`);
+        console.error(err.stack);
+        return false;
+    } finally {
+        await runner.cleanup();
+    }
+}
+
+function assert(condition, message) {
+    if (!condition) {
+        throw new Error(message || 'Assertion failed');
+    }
+}
+
+// Run sync tests
+console.log('[SUCCESS] Stigmergy Skills Sync Functionality Test\n');
+console.log('Verify multi-CLI config file sync\n');
+
+runSyncTests()
+    .then(success => {
+        if (success) {
+            console.log('\n[SUCCESS] All sync tests passed!');
+        }
+        process.exit(success ? 0 : 1);
+    })
+    .catch(err => {
+        console.error('[X] Test execution failed:', err);
+        process.exit(1);
+    });