stigmergy 1.2.12 → 1.3.1-beta

package/src/core/multilingual/language-pattern-manager.js

@@ -179,7 +179,7 @@ class LanguagePatternManager {
         
         // Validate that the target CLI is supported
         const supportedCLIs = [
-          'claude', 'gemini', 'qwen', 'iflow', 'qodercli', 'codebuddy', 'codex', 'copilot'
+          'claude', 'gemini', 'qwen', 'iflow', 'qodercli', 'codebuddy', 'codex', 'copilot', 'kode'
         ];
         
         if (supportedCLIs.includes(targetCLI)) {

package/src/core/skills/BuiltinSkillsDeployer.js

@@ -0,0 +1,188 @@
+/**
+ * BuiltinSkillsDeployer - Deploy built-in skills to CLI tools
+ * Automatically deploys stigmergy built-in skills during installation
+ */
+
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+
+class BuiltinSkillsDeployer {
+  constructor() {
+    this.configPath = path.join(process.cwd(), 'config', 'builtin-skills.json');
+    this.skillsBaseDir = process.cwd();
+  }
+
+  /**
+   * Load built-in skills configuration
+   */
+  loadConfig() {
+    try {
+      if (!fs.existsSync(this.configPath)) {
+        console.warn('[BUILTIN_SKILLS] No built-in skills configuration found');
+        return null;
+      }
+
+      const content = fs.readFileSync(this.configPath, 'utf8');
+      return JSON.parse(content);
+    } catch (error) {
+      console.error('[BUILTIN_SKILLS] Failed to load configuration:', error.message);
+      return null;
+    }
+  }
+
+  /**
+   * Deploy built-in skills to all CLI tools
+   */
+  async deployAll() {
+    const config = this.loadConfig();
+    if (!config) {
+      return { success: false, message: 'No built-in skills configuration found' };
+    }
+
+    console.log(`[BUILTIN_SKILLS] Found ${config.skills.length} built-in skill(s)`);
+
+    const results = [];
+    for (const skill of config.skills) {
+      if (skill.deployment && skill.deployment.autoDeploy) {
+        const result = await this.deploySkill(skill);
+        results.push(result);
+      }
+    }
+
+    const successCount = results.filter(r => r.success).length;
+    console.log(`[BUILTIN_SKILLS] Deployed ${successCount}/${results.length} skill(s)`);
+
+    return { success: true, results };
+  }
+
+  /**
+   * Deploy a single built-in skill to target CLIs
+   */
+  async deploySkill(skill) {
+    const targetCLIs = skill.deployment.targetCLIs || [];
+    const results = [];
+
+    for (const cliName of targetCLIs) {
+      const result = await this.deployToCLI(skill, cliName);
+      results.push(result);
+    }
+
+    const successCount = results.filter(r => r.success).length;
+    return {
+      success: successCount === results.length,
+      skillName: skill.name,
+      targetCLIs: targetCLIs,
+      deployedCount: successCount,
+      results
+    };
+  }
+
+  /**
+   * Deploy skill to a specific CLI
+   */
+  async deployToCLI(skill, cliName) {
+    try {
+      const cliHomeDir = path.join(os.homedir(), `.${cliName}`);
+
+      // Check if CLI exists
+      if (!fs.existsSync(cliHomeDir)) {
+        console.warn(`[BUILTIN_SKILLS] CLI not found: ${cliName} (${cliHomeDir})`);
+        return { success: false, cliName, skillName: skill.name, error: 'CLI not installed' };
+      }
+
+      // Ensure skills directory exists
+      const cliSkillsRootDir = path.join(cliHomeDir, 'skills');
+      if (!fs.existsSync(cliSkillsRootDir)) {
+        try {
+          fs.mkdirSync(cliSkillsRootDir, { recursive: true });
+        } catch (error) {
+          console.error(`[BUILTIN_SKILLS] Failed to create skills root directory for ${cliName}:`, error.message);
+          return { success: false, cliName, skillName: skill.name, error: error.message };
+        }
+      }
+
+      const cliSkillsDir = path.join(cliSkillsRootDir, skill.name);
+
+      // Create skills directory
+      if (!fs.existsSync(cliSkillsDir)) {
+        try {
+          fs.mkdirSync(cliSkillsDir, { recursive: true });
+        } catch (error) {
+          console.error(`[BUILTIN_SKILLS] Failed to create skills directory for ${cliName}:`, error.message);
+          return { success: false, cliName, skillName: skill.name, error: error.message };
+        }
+      }
+
+      // Get actual Stigmergy installation path for placeholder replacement
+      const stigmergyPath = process.cwd();
+
+      // Copy skill files
+      const files = skill.deployment.files || [];
+      for (const file of files) {
+        const sourcePath = path.join(this.skillsBaseDir, file.source);
+        const destPath = path.join(cliSkillsDir, path.basename(file.destination));
+
+        if (!fs.existsSync(sourcePath)) {
+          console.warn(`[BUILTIN_SKILLS] Source file not found: ${sourcePath}`);
+          continue;
+        }
+
+        try {
+          let content = fs.readFileSync(sourcePath, 'utf8');
+          // Replace placeholders with actual paths
+          content = content.replace(/\{stigmergy_path\}/g, stigmergyPath);
+          fs.writeFileSync(destPath, content);
+          console.log(`[BUILTIN_SKILLS] Deployed ${file.source} to ${cliName}`);
+        } catch (error) {
+          console.error(`[BUILTIN_SKILLS] Failed to copy ${file.source} to ${cliName}:`, error.message);
+          return { success: false, cliName, skillName: skill.name, error: error.message };
+        }
+      }
+
+      return { success: true, cliName, skillName: skill.name };
+    } catch (error) {
+      console.error(`[BUILTIN_SKILLS] Failed to deploy ${skill.name} to ${cliName}:`, error.message);
+      return { success: false, cliName, skillName: skill.name, error: error.message };
+    }
+  }
+
+  /**
+   * Check if a skill is deployed to a CLI
+   */
+  isDeployed(skillName, cliName) {
+    const cliSkillsDir = path.join(os.homedir(), `.${cliName}`, 'skills', skillName);
+    return fs.existsSync(cliSkillsDir);
+  }
+
+  /**
+   * Get deployment status for all built-in skills
+   */
+  getDeploymentStatus() {
+    const config = this.loadConfig();
+    if (!config) {
+      return null;
+    }
+
+    const status = [];
+    for (const skill of config.skills) {
+      const skillStatus = {
+        name: skill.name,
+        displayName: skill.displayName,
+        version: skill.version,
+        deployment: {}
+      };
+
+      const targetCLIs = skill.deployment.targetCLIs || [];
+      for (const cliName of targetCLIs) {
+        skillStatus.deployment[cliName] = this.isDeployed(skill.name, cliName);
+      }
+
+      status.push(skillStatus);
+    }
+
+    return status;
+  }
+}
+
+export default BuiltinSkillsDeployer;

package/src/core/skills/StigmergySkillManager.js

@@ -121,23 +121,45 @@ export class StigmergySkillManager {
 
     /**
      * Sync skills to CLI configuration files
+     * Also copies skills to CLI-specific directories and refreshes cache
      * @returns {Promise<void>}
      */
     async sync() {
-        console.log('[INFO] Syncing skills to CLI configuration files...');
-        
+        console.log('[INFO] Syncing skills to CLI directories...');
+
         try {
+            // Refresh the LocalSkillScanner cache
+            try {
+                // Import LocalSkillScanner (it's a CommonJS module)
+                const { createRequire } = await import('module');
+                const require = createRequire(import.meta.url);
+                const LocalSkillScanner = require('./local_skill_scanner.js');
+
+                const scanner = new LocalSkillScanner();
+                await scanner.initialize(true); // Force refresh
+                console.log('[INFO] Refreshed skills/agents cache');
+            } catch (err) {
+                // LocalSkillScanner might not be available, ignore
+                if (process.env.DEBUG === 'true') {
+                    console.log('[DEBUG] LocalSkillScanner not available:', err.message);
+                }
+            }
+
             const skills = await this.reader.listSkills();
-            
+
             if (skills.length === 0) {
                 console.log('[INFO] No skills to sync');
                 return;
             }
-            
-            // Generate <available_skills> XML
+
+            // Step 1: Copy skills to CLI-specific directories
+            console.log('[INFO] Copying skills to CLI directories...');
+            const copyResults = await this.syncSkillFiles(skills);
+
+            // Step 2: Generate <available_skills> XML
             const skillsXml = this.generateSkillsXml(skills);
-            
-            // All CLI configuration files to update
+
+            // Step 3: All CLI configuration files to update
             const cliFiles = [
                 'AGENTS.md',      // Universal config
                 'claude.md',      // Claude CLI
@@ -147,17 +169,19 @@ export class StigmergySkillManager {
                 'qodercli.md',    // Qoder CLI
                 'codebuddy.md',   // CodeBuddy CLI
                 'copilot.md',     // Copilot CLI
-                'codex.md'        // Codex CLI
+                'codex.md',       // Codex CLI
+                'opencode.md',    // OpenCode CLI
+                'oh-my-opencode.md' // Oh-My-OpenCode Plugin Manager
             ];
-            
+
             let syncedCount = 0;
             let createdCount = 0;
             let skippedCount = 0;
-            
+
             // Iterate through all CLI configuration files
             for (const fileName of cliFiles) {
                 const filePath = path.join(process.cwd(), fileName);
-                
+
                 try {
                     const result = await this.syncToFile(filePath, fileName, skillsXml);
                     if (result === 'synced') {
@@ -170,22 +194,105 @@ export class StigmergySkillManager {
                     skippedCount++;
                 }
             }
-            
+
             // Output sync result summary
             console.log(`\n[OK] Sync completed:`);
-            console.log(`   - Updated: ${syncedCount} file(s)`);
+            console.log(`   - Skills copied: ${copyResults.copied} to ${copyResults.targets} CLI directory(ies)`);
+            console.log(`   - Config updated: ${syncedCount} file(s)`);
             if (createdCount > 0) {
-                console.log(`   - Created: ${createdCount} file(s)`);
+                console.log(`   - Config created: ${createdCount} file(s)`);
             }
             if (skippedCount > 0) {
-                console.log(`   - Skipped: ${skippedCount} file(s)`);
+                console.log(`   - Config skipped: ${skippedCount} file(s)`);
             }
-            console.log(`   - Skills: ${skills.length}`);
+            console.log(`   - Total skills: ${skills.length}`);
         } catch (err) {
             console.error(`[X] Sync failed: ${err.message}`);
             throw err;
         }
     }
+
+    /**
+     * Copy skill files to CLI-specific directories
+     * @private
+     * @param {Array} skills - List of skills to copy
+     * @returns {Promise<Object>} Copy results
+     */
+    async syncSkillFiles(skills) {
+        const fsPromises = await import('fs/promises');
+
+        // Define CLI skill directories
+        const cliSkillDirs = [
+            { name: 'Claude', path: path.join(os.homedir(), '.claude', 'skills') },
+            { name: 'Universal', path: path.join(process.cwd(), '.agent', 'skills') },
+            { name: 'Universal (global)', path: path.join(os.homedir(), '.agent', 'skills') }
+        ];
+
+        let copiedCount = 0;
+        let targets = 0;
+
+        for (const cliDir of cliSkillDirs) {
+            try {
+                // Ensure CLI directory exists
+                await fsPromises.mkdir(cliDir.path, { recursive: true });
+
+                // Copy each skill
+                for (const skill of skills) {
+                    const skillName = skill.name;
+                    const sourceDir = path.join(this.skillsDir, skillName);
+                    const targetDir = path.join(cliDir.path, skillName);
+
+                    try {
+                        // Check if source exists
+                        await fsPromises.access(sourceDir);
+
+                        // Remove existing if present
+                        await fsPromises.rm(targetDir, { recursive: true, force: true });
+
+                        // Copy directory
+                        await this.copyDirectoryRecursive(sourceDir, targetDir);
+                        copiedCount++;
+                    } catch (err) {
+                        // Skip if source doesn't exist or copy fails
+                        if (process.env.DEBUG === 'true') {
+                            console.log(`[DEBUG] Skipped ${skillName} for ${cliDir.name}: ${err.message}`);
+                        }
+                    }
+                }
+
+                targets++;
+                console.log(`   [OK] Synced to ${cliDir.name}: ${cliDir.path}`);
+            } catch (err) {
+                console.log(`   [INFO] Skipped ${cliDir.name}: ${err.message}`);
+            }
+        }
+
+        return { copied: copiedCount, targets: targets };
+    }
+
+    /**
+     * Recursively copy a directory
+     * @private
+     * @param {string} src - Source directory
+     * @param {string} dest - Destination directory
+     */
+    async copyDirectoryRecursive(src, dest) {
+        const fsPromises = await import('fs/promises');
+
+        await fsPromises.mkdir(dest, { recursive: true });
+        const entries = await fsPromises.readdir(src, { withFileTypes: true });
+
+        for (const entry of entries) {
+            const srcPath = path.join(src, entry.name);
+            const destPath = path.join(dest, entry.name);
+
+            if (entry.isDirectory()) {
+                await this.copyDirectoryRecursive(srcPath, destPath);
+            } else {
+                await fsPromises.copyFile(srcPath, destPath);
+            }
+        }
+    }
     
     /**
      * Sync skills to a single file

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

@@ -13,7 +13,9 @@ export class SkillParser {
      * @returns {Object} Parsed metadata
      */
     parseMetadata(content) {
-        const match = content.match(/^---\n(.*?)\n---/s);
+        // Normalize line endings to LF
+        const normalizedContent = content.replace(/\r\n/g, '\n');
+        const match = normalizedContent.match(/^---\n(.*?)\n---/s);
         if (!match) {
             return {};
         }
@@ -78,8 +80,10 @@ export class SkillParser {
      * @returns {string} Content without frontmatter
      */
     extractContent(content) {
-        const match = content.match(/^---\n.*?\n---\n(.*)$/s);
-        return match ? match[1].trim() : content;
+        // Normalize line endings to LF
+        const normalizedContent = content.replace(/\r\n/g, '\n');
+        const match = normalizedContent.match(/^---\n.*?\n---\n(.*)$/s);
+        return match ? match[1].trim() : normalizedContent;
     }
 
     /**