stigmergy 1.2.8 → 1.2.10

package/src/core/skills/embedded-openskills/SkillParser.js

@@ -0,0 +1,123 @@
+/**
+ * SkillParser - Parse SKILL.md files
+ * 
+ * Adapted from: https://github.com/numman-ali/openskills
+ * Original License: Apache 2.0
+ * Modifications: Copyright Stigmergy Project
+ */
+
+export class SkillParser {
+    /**
+     * Parse YAML frontmatter from skill content
+     * @param {string} content - Full SKILL.md content
+     * @returns {Object} Parsed metadata
+     */
+    parseMetadata(content) {
+        const match = content.match(/^---\n(.*?)\n---/s);
+        if (!match) {
+            return {};
+        }
+
+        const yamlContent = match[1];
+        const metadata = {};
+        
+        const lines = yamlContent.split('\n');
+        let currentKey = null;
+        let currentArray = null;
+        
+        for (const line of lines) {
+            // Handle array items
+            if (line.trim().startsWith('-') && currentKey) {
+                const value = line.trim().substring(1).trim();
+                if (!currentArray) {
+                    currentArray = [];
+                    metadata[currentKey] = currentArray;
+                }
+                currentArray.push(value);
+                continue;
+            }
+            
+            // Handle key-value pairs
+            const colonIndex = line.indexOf(':');
+            if (colonIndex > 0) {
+                currentKey = line.substring(0, colonIndex).trim();
+                let value = line.substring(colonIndex + 1).trim();
+                
+                // Reset array tracking
+                currentArray = null;
+                
+                // Handle multiline values (>)
+                if (value === '>') {
+                    continue; // Next lines will be the value
+                }
+                
+                // Remove quotes
+                if ((value.startsWith('"') && value.endsWith('"')) ||
+                    (value.startsWith("'") && value.endsWith("'"))) {
+                    value = value.slice(1, -1);
+                }
+                
+                if (value) {
+                    metadata[currentKey] = value;
+                }
+            } else if (currentKey && line.trim()) {
+                // Multiline continuation
+                const existingValue = metadata[currentKey];
+                metadata[currentKey] = existingValue 
+                    ? `${existingValue} ${line.trim()}`
+                    : line.trim();
+            }
+        }
+        
+        return metadata;
+    }
+
+    /**
+     * Extract content after frontmatter
+     * @param {string} content - Full SKILL.md content
+     * @returns {string} Content without frontmatter
+     */
+    extractContent(content) {
+        const match = content.match(/^---\n.*?\n---\n(.*)$/s);
+        return match ? match[1].trim() : content;
+    }
+
+    /**
+     * Validate skill structure and content
+     * @param {string} content - Full SKILL.md content
+     * @returns {Object} Validation result with valid flag and errors array
+     */
+    validateSkill(content) {
+        const errors = [];
+        const metadata = this.parseMetadata(content);
+        
+        // Required fields
+        if (!metadata.name) {
+            errors.push('Missing required field: name');
+        }
+        
+        if (!metadata.description) {
+            errors.push('Missing required field: description');
+        }
+        
+        // Name format validation
+        if (metadata.name && !/^[a-z0-9-]+$/.test(metadata.name)) {
+            errors.push('Skill name must use lowercase and hyphens only');
+        }
+        
+        // Content length validation (approximate word count)
+        const mainContent = this.extractContent(content);
+        const wordCount = mainContent.split(/\s+/).length;
+        
+        if (wordCount > 5000) {
+            errors.push('SKILL.md content exceeds 5000 words');
+        }
+        
+        return {
+            valid: errors.length === 0,
+            errors: errors,
+            metadata: metadata,
+            wordCount: wordCount
+        };
+    }
+}

package/src/core/skills/embedded-openskills/SkillReader.js

@@ -0,0 +1,143 @@
+/**
+ * SkillReader - Read and locate skills
+ * 
+ * Adapted from: https://github.com/numman-ali/openskills
+ * Original License: Apache 2.0
+ * Modifications: Copyright Stigmergy Project
+ */
+
+import fs from 'fs/promises';
+import path from 'path';
+import os from 'os';
+import { SkillParser } from './SkillParser.js';
+
+export class SkillReader {
+    /**
+     * @param {string[]} customSearchPaths - Optional custom search paths
+     */
+    constructor(customSearchPaths = null) {
+        this.parser = new SkillParser();
+        
+        if (customSearchPaths) {
+            this.searchPaths = customSearchPaths;
+        } else {
+            // Default search paths (priority order)
+            this.searchPaths = [
+                path.join(process.cwd(), '.agent/skills'),       // Project universal
+                path.join(os.homedir(), '.agent/skills'),        // Global universal
+                path.join(process.cwd(), '.claude/skills'),      // Project Claude
+                path.join(os.homedir(), '.claude/skills'),       // Global Claude
+                path.join(os.homedir(), '.stigmergy/skills')     // Stigmergy unified
+            ];
+        }
+    }
+
+    /**
+     * Find skill in search paths
+     * @param {string} name - Skill name
+     * @returns {Promise<Object|null>} Skill info or null if not found
+     */
+    async findSkill(name) {
+        for (const basePath of this.searchPaths) {
+            const skillPath = path.join(basePath, name, 'SKILL.md');
+            
+            try {
+                await fs.access(skillPath);
+                return {
+                    name: name,
+                    path: skillPath,
+                    baseDir: path.dirname(skillPath)
+                };
+            } catch {
+                // Continue to next path
+                continue;
+            }
+        }
+        
+        return null;
+    }
+
+    /**
+     * Read skill content
+     * @param {string} name - Skill name
+     * @returns {Promise<Object>} Skill data with name, baseDir, and content
+     */
+    async readSkill(name) {
+        const skill = await this.findSkill(name);
+        
+        if (!skill) {
+            throw new Error(`Skill '${name}' not found in any search path`);
+        }
+
+        const content = await fs.readFile(skill.path, 'utf-8');
+        
+        return {
+            name: skill.name,
+            baseDir: skill.baseDir,
+            content: content
+        };
+    }
+
+    /**
+     * List all available skills
+     * @returns {Promise<Array>} Array of skill info objects
+     */
+    async listSkills() {
+        const skills = [];
+        const seenNames = new Set();
+        
+        for (const searchPath of this.searchPaths) {
+            try {
+                const entries = await fs.readdir(searchPath, { withFileTypes: true });
+                
+                for (const entry of entries) {
+                    if (!entry.isDirectory()) continue;
+                    if (seenNames.has(entry.name)) continue; // Skip duplicates
+                    
+                    const skillPath = path.join(searchPath, entry.name, 'SKILL.md');
+                    
+                    try {
+                        await fs.access(skillPath);
+                        const content = await fs.readFile(skillPath, 'utf-8');
+                        const metadata = this.parser.parseMetadata(content);
+                        
+                        skills.push({
+                            name: entry.name,
+                            description: metadata.description || '',
+                            location: this.determineLocation(searchPath),
+                            path: skillPath
+                        });
+                        
+                        seenNames.add(entry.name);
+                    } catch {
+                        // Not a valid skill directory, skip
+                        continue;
+                    }
+                }
+            } catch {
+                // Search path doesn't exist, skip
+                continue;
+            }
+        }
+        
+        return skills;
+    }
+
+    /**
+     * Determine skill location type from path
+     * @private
+     */
+    determineLocation(searchPath) {
+        if (searchPath.includes('.stigmergy')) {
+            return 'stigmergy';
+        } else if (searchPath.includes('.agent')) {
+            return 'universal';
+        } else if (searchPath.includes('.claude')) {
+            return 'claude';
+        } else if (searchPath.includes(process.cwd())) {
+            return 'project';
+        } else {
+            return 'global';
+        }
+    }
+}

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

@@ -0,0 +1,248 @@
+/**
+ * Integration Test - End-to-end verification of Stigmergy Skills System
+ * 
+ * TDD Verification:
+ * 1. Create test skills
+ * 2. Install skills
+ * 3. Read skills
+ * 4. List skills
+ * 5. Sync to AGENTS.md
+ * 6. Validate skills
+ * 7. Remove skills
+ */
+
+import { StigmergySkillManager } from './StigmergySkillManager.js';
+import fs from 'fs/promises';
+import path from 'path';
+import os from 'os';
+
+class IntegrationTestRunner {
+    constructor() {
+        this.testDir = path.join(os.tmpdir(), `stigmergy-integration-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 skill repository structure
+        const repoDir = path.join(this.testDir, 'test-repo');
+        await fs.mkdir(repoDir, { recursive: true });
+
+        // Create test skill #1
+        const skill1Dir = path.join(repoDir, 'test-analyzer');
+        await fs.mkdir(skill1Dir, { recursive: true });
+        await fs.writeFile(
+            path.join(skill1Dir, 'SKILL.md'),
+            `---
+name: test-analyzer
+description: Test data analysis skill for integration testing
+version: 1.0.0
+---
+
+# Test Analyzer
+
+## Trigger Conditions
+When user asks to analyze test data.
+
+## Core Workflow
+
+### Step 1: Data Loading
+1. Read input file
+2. Validate format
+
+### Step 2: Execute Analysis
+Run analysis script:
+\`\`\`bash
+python scripts/analyze.py --input data.json
+\`\`\`
+
+### Step 3: Generate Report
+Output results to report.json
+`
+        );
+
+        // Add scripts directory
+        await fs.mkdir(path.join(skill1Dir, 'scripts'));
+        await fs.writeFile(
+            path.join(skill1Dir, 'scripts', 'analyze.py'),
+            `#!/usr/bin/env python3
+import json
+import sys
+
+data = json.load(sys.stdin)
+print(json.dumps({"status": "analyzed", "count": len(data)}, indent=2))
+`
+        );
+
+        // Create test skill #2
+        const skill2Dir = path.join(repoDir, 'test-formatter');
+        await fs.mkdir(skill2Dir);
+        await fs.writeFile(
+            path.join(skill2Dir, 'SKILL.md'),
+            `---
+name: test-formatter
+description: Test code formatting skill
+---
+
+# Test Formatter
+
+Format code according to standards.
+`
+        );
+
+        console.log(`[OK] Test repository created at ${repoDir}\n`);
+        return repoDir;
+    }
+
+    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(`Integration 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 runIntegrationTests() {
+    const runner = new IntegrationTestRunner();
+
+    try {
+        // Setup
+        const repoDir = await runner.setup();
+
+        console.log('[LIST] Running integration tests...\n');
+
+        // Test 1: Scan skills
+        await runner.test('Scan local skill repository', async () => {
+            const skills = await runner.manager.installer.scanSkills(repoDir);
+            assert(skills.length === 2, `Expected 2 skills, got ${skills.length}`);
+            assert(skills.some(s => s.name === 'test-analyzer'), 'Missing test-analyzer');
+            assert(skills.some(s => s.name === 'test-formatter'), 'Missing test-formatter');
+        });
+
+        // Test 2: Install skill manually
+        await runner.test('Install single skill', async () => {
+            const skills = await runner.manager.installer.scanSkills(repoDir);
+            const skill = skills.find(s => s.name === 'test-analyzer');
+            await runner.manager.installer.installSkill(skill);
+            
+            // Verify installation
+            const installed = await fs.access(
+                path.join(runner.testDir, 'skills', 'test-analyzer', 'SKILL.md')
+            ).then(() => true).catch(() => false);
+            assert(installed, 'Skill not installed');
+        });
+
+        // Test 3: Read installed skill
+        await runner.test('Read installed skill', async () => {
+            const skill = await runner.manager.reader.readSkill('test-analyzer');
+            assert(skill.name === 'test-analyzer', `Expected name 'test-analyzer', got '${skill.name}'`);
+            assert(skill.content.includes('Test Analyzer'), 'Missing expected content');
+            assert(skill.baseDir.includes('test-analyzer'), 'Invalid base directory');
+        });
+
+        // Test 4: List all skills
+        await runner.test('List all installed skills', async () => {
+            const skills = await runner.manager.reader.listSkills();
+            assert(skills.length >= 1, 'No skills found');
+            assert(skills.some(s => s.name === 'test-analyzer'));
+        });
+
+        // Test 5: Validate skill format
+        await runner.test('Validate skill format', async () => {
+            const validation = await runner.manager.validate('test-analyzer');
+            assert(validation.valid === true, `Skill validation failed: ${validation.errors.join(', ')}`);
+        });
+
+        // Test 6: Sync to AGENTS.md
+        await runner.test('Sync skills to AGENTS.md', async () => {
+            // Create temporary AGENTS.md
+            const agentsMdPath = path.join(runner.testDir, 'AGENTS.md');
+            await fs.writeFile(agentsMdPath, '# Test AGENTS.md\n\n');
+            
+            // Change working directory
+            const originalCwd = process.cwd();
+            process.chdir(runner.testDir);
+            
+            try {
+                await runner.manager.sync();
+                
+                // Verify AGENTS.md updated
+                const content = await fs.readFile(agentsMdPath, 'utf-8');
+                assert(content.includes('<available_skills>'), 'Missing skills section');
+                assert(content.includes('test-analyzer'), 'Missing test-analyzer in AGENTS.md');
+            } finally {
+                process.chdir(originalCwd);
+            }
+        });
+
+        // Test 7: Remove skill
+        await runner.test('Remove skill', async () => {
+            await runner.manager.installer.uninstallSkill('test-analyzer');
+            
+            // Verify removal
+            const exists = await fs.access(
+                path.join(runner.testDir, 'skills', 'test-analyzer')
+            ).then(() => true).catch(() => false);
+            assert(!exists, 'Skill still exists after removal');
+        });
+
+        return runner.summary();
+    } catch (err) {
+        console.error(`\n[X] Integration 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 integration tests
+console.log('[SUCCESS] Stigmergy Skills Integration Test\n');
+console.log('TDD-driven, embedded OpenSkills core\n');
+
+runIntegrationTests()
+    .then(success => {
+        if (success) {
+            console.log('\n[SUCCESS] All integration tests passed!');
+            console.log('\nNext steps:');
+            console.log('  1. Integrate into stigmergy CLI main command');
+            console.log('  2. Test real GitHub repository installation');
+            console.log('  3. Verify integration with all CLI tools');
+        }
+        process.exit(success ? 0 : 1);
+    })
+    .catch(err => {
+        console.error('[X] Test execution failed:', err);
+        process.exit(1);
+    });

package/src/core/skills/package.json

@@ -0,0 +1,6 @@
+{
+  "type": "module",
+  "name": "@stigmergy/skills-core",
+  "version": "1.0.0",
+  "private": true
+}