stigmergy 1.3.13 → 1.3.15

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "stigmergy",
-  "version": "1.3.13",
+  "version": "1.3.15",
   "description": "Stigmergy CLI - Multi-Agents Cross-AI CLI Tools Collaboration System",
   "main": "src/index.js",
   "bin": {

package/src/cli/commands/project.js

@@ -16,6 +16,7 @@ const LocalSkillScanner = require('../../core/local_skill_scanner');
 const CLIHelpAnalyzer = require('../../core/cli_help_analyzer');
 const { CLI_TOOLS } = require('../../core/cli_tools');
 const { ensureSkillsCache } = require('../utils/skills_cache');
+const packageJson = require('../../../package.json');
 
 // Import execution mode detection and CLI adapters
 const ExecutionModeDetector = require('../../core/execution_mode_detector');
@@ -150,7 +151,7 @@ async function handleInitCommand(options = {}) {
 
     // Create basic config
     const config = {
-      version: '1.3.8',
+      version: packageJson.version,
       created: new Date().toISOString(),
       project: path.basename(projectDir)
     };

package/src/cli/commands/resume.js

@@ -1,6 +1,6 @@
 /**
  * Resume Session Commands
- * Modular implementation for resume/resumesession/sg-resume commands
+ * Modular implementation for resume command
  */
 
 const chalk = require('chalk');
@@ -47,7 +47,7 @@ async function handleResumeCommand(args = [], options = {}) {
       console.log(chalk.yellow('[INFO] ResumeSession is an optional component for session recovery'));
 
       console.log(chalk.blue('\n📦 To install ResumeSession:'));
-      console.log('  npm install -g @stigmergy/resume');
+      console.log('  npm install -g resumesession');
       console.log('');
       console.log(chalk.blue('🔧 ResumeSession provides:'));
       console.log('  • Cross-CLI session history');
@@ -100,18 +100,16 @@ function printResumeHelp() {
   console.log(chalk.cyan(`
 🔄 Stigmergy Resume Session System
 
-📋 ResumeSession forwards to the @stigmergy/resume CLI tool for session management.
+📋 ResumeSession forwards to the resumesession CLI tool for session management.
 
 🛠️  Available Commands:
   stigmergy resume [args]              Forward to resumesession CLI
-  stigmergy resumesession [args]       Same as resume (full name)
-  stigmergy sg-resume [args]           Same as resume (short alias)
 
 📦 Requirements:
-  @stigmergy/resume CLI tool must be installed separately.
+  resumesession CLI tool must be installed separately.
 
 💾 Installation:
-  npm install -g @stigmergy/resume
+  npm install -g resumesession
 
 🔍 Common Usage:
   stigmergy resume list                # Show available sessions

package/src/cli/router-beta.js

@@ -92,10 +92,11 @@ function addOAuthAuthArgs(toolName, args = []) {
  */
 async function main() {
   const program = new Command();
+  const packageJson = require('../../package.json');
 
   // Program setup
   program
-    .version('1.3.8')
+    .version(packageJson.version)
     .description('Stigmergy CLI - Multi-Agents Cross-AI CLI Tools Collaboration System')
     .name('stigmergy');
 
@@ -319,7 +320,7 @@ async function main() {
       await handleAutoInstallCommand(options);
     });
 
-  // Resume session commands
+  // Resume session command
   program
     .command('resume')
     .description('Resume session (forwards to @stigmergy/resume CLI tool)')
@@ -329,26 +330,8 @@ async function main() {
       await handleResumeCommand(args, options);
     });
 
-  program
-    .command('resumesession')
-    .description('Resume session management (forwards to @stigmergy/resume)')
-    .argument('[args...]', 'Arguments to pass to resumesession')
-    .option('-v, --verbose', 'Verbose output')
-    .action(async (args, options) => {
-      await handleResumeCommand(args, options);
-    });
-
-  program
-    .command('sg-resume')
-    .description('Resume session management (short alias)')
-    .argument('[args...]', 'Arguments to pass to resumesession')
-    .option('-v, --verbose', 'Verbose output')
-    .action(async (args, options) => {
-      await handleResumeCommand(args, options);
-    });
-
   // Route commands to CLI tools
-  for (const tool of ['claude', 'gemini', 'qwen', 'codebuddy', 'codex', 'iflow', 'qodercli', 'copilot', 'kode', 'resumesession']) {
+  for (const tool of ['claude', 'gemini', 'qwen', 'codebuddy', 'codex', 'iflow', 'qodercli', 'copilot', 'kode', 'opencode', 'oh-my-opencode']) {
     program
       .command(tool)
       .description(`Use ${tool} CLI tool`)

package/src/core/cli_tools.js

@@ -76,6 +76,22 @@ const CLI_TOOLS = {
     hooksDir: path.join(os.homedir(), '.resumesession', 'hooks'),
     config: path.join(os.homedir(), '.resumesession', 'config.json'),
   },
+  opencode: {
+    name: 'OpenCode AI CLI',
+    version: 'opencode --version',
+    install: 'npm install -g opencode-ai',
+    hooksDir: path.join(os.homedir(), '.opencode', 'hooks'),
+    config: path.join(os.homedir(), '.opencode', 'config.json'),
+  },
+  'oh-my-opencode': {
+    name: 'Oh-My-OpenCode Plugin Manager',
+    version: 'oh-my-opencode --version',
+    install: 'npm install bun -g && bunx oh-my-opencode install --no-tui --claude=no --chatgpt=no --gemini=no',
+    hooksDir: path.join(os.homedir(), '.opencode', 'plugins'),
+    config: path.join(os.homedir(), '.opencode', 'config.json'),
+    skipVersionCheck: true, // Version check may not work properly for bunx packages
+    requiresBun: true, // Requires bun runtime
+  },
 };
 
 /**

package/src/core/coordination/nodejs/CLIIntegrationManager.js

@@ -72,6 +72,24 @@ class CLIIntegrationManager {
         executable: 'copilot',
         mcp: ['cross_cli_execute'],
       },
+      opencode: {
+        name: 'OpenCode AI CLI',
+        executable: 'opencode',
+        skills: [
+          'on_skill_invocation',
+          'on_code_generation',
+          'on_cross_cli_task',
+        ],
+      },
+      'oh-my-opencode': {
+        name: 'Oh-My-OpenCode Plugin Manager',
+        executable: 'oh-my-opencode',
+        plugins: [
+          'on_plugin_install',
+          'on_plugin_load',
+          'on_cross_cli_integration',
+        ],
+      },
     };
   }
 

package/src/core/coordination/nodejs/HookDeploymentManager.js

@@ -20,7 +20,9 @@ class HookDeploymentManager {
       'codebuddy',
       'codex',
       'copilot',
-      'kode'
+      'kode',
+      'opencode',
+      'oh-my-opencode'
       // Note: 'resumesession' is handled separately as a session recovery tool, not a regular CLI
     ];
 

package/src/core/coordination/nodejs/generators/ResumeSessionGenerator.js

@@ -7,7 +7,8 @@ class ResumeSessionGenerator {
   constructor() {
     this.supportedCLIs = [
       'claude', 'gemini', 'qwen', 'codebuddy', 'codex',
-      'iflow', 'qodercli', 'copilot', 'kode', 'resumesession'
+      'iflow', 'qodercli', 'copilot', 'kode', 'opencode',
+      'oh-my-opencode', 'resumesession'
     ];
   }
 
@@ -534,8 +535,8 @@ function buildQuery(input) {
     search: null
   };
 
-  const cleanInput = input.replace(new RegExp('^\\\\\\\\/?' + '${commandName}' + '\\\\\s*', 'i'), '').trim();
-  const parts = cleanInput.split(/\\\s+/).filter(p => p.length > 0);
+  const cleanInput = input.replace(new RegExp('^\\\\\\\\/?' + '${commandName}' + '\\\\\\s*', 'i'), '').trim();
+  const parts = cleanInput.split(/\\\\s+/).filter(p => p.length > 0);
 
   for (let i = 0; i < parts.length; i++) {
     const part = parts[i].toLowerCase();
@@ -624,8 +625,8 @@ class GeminiHistoryHandler {
       search: null
     };
 
-    const cleanInput = input.replace(new RegExp('^\\\\\\\\/?' + this.commandName + '\\\\\s*', 'i'), '').trim();
-    const parts = cleanInput.split(/\\\s+/).filter(p => p.length > 0);
+    const cleanInput = input.replace(new RegExp('^\\\\\\\\/?' + this.commandName + '\\\\\\s*', 'i'), '').trim();
+    const parts = cleanInput.split(/\\\\s+/).filter(p => p.length > 0);
 
     for (let i = 0; i < parts.length; i++) {
       const part = parts[i].toLowerCase();

package/src/core/coordination/nodejs/generators/SkillsIntegrationGenerator.js

@@ -59,8 +59,8 @@ class SkillsIntegrationGenerator {
     return `"""
 Claude CLI Skills Integration Hook
 Auto-generated by Stigmergy CLI v1.2.1
-Project: ${projectPath}
-Skills Directory: ${skillsDir}
+Project: ${projectPath.replace(/\\/g, '/')}
+Skills Directory: ${skillsDir.replace(/\\/g, '/')}
 
 This hook provides skills integration for Claude CLI with dynamic loading
 and execution of skills from the centralized skills directory.
@@ -75,7 +75,7 @@ from typing import Dict, List, Optional, Any
 
 class ClaudeSkillsHook:
     def __init__(self):
-        self.skills_dir = Path("${skillsDir.replace(/\\/g, '\\\\')}")
+        self.skills_dir = Path("${skillsDir.replace(/\\/g, '/')}")
         self.loaded_skills = {}
         self.skill_metadata = {}
 
@@ -105,7 +105,21 @@ class ClaudeSkillsHook:
     def load_skill(self, skill_dir):
         """Load a single skill from directory"""
         try:
-            # Check for skill implementation files
+            # Check for skill implementation files in scripts subdirectory
+            scripts_dir = skill_dir / 'scripts'
+            if scripts_dir.exists() and scripts_dir.is_dir():
+                for py_file in scripts_dir.glob("*.py"):
+                    if py_file.name != "test_skill.py":  # Skip test files
+                        spec = importlib.util.spec_from_file_location(
+                            f"{skill_dir.name}.{py_file.stem}", py_file
+                        )
+                        if spec and spec.loader:
+                            module = importlib.util.module_from_spec(spec)
+                            spec.loader.exec_module(module)
+                            print(f"[CLAUDE_SKILLS]  Loaded module: {py_file.name}")
+                            return module
+
+            # Fallback: check for Python files in root directory
             for py_file in skill_dir.glob("*.py"):
                 if py_file.name != "test_skill.py":  # Skip test files
                     spec = importlib.util.spec_from_file_location(
@@ -114,7 +128,14 @@ class ClaudeSkillsHook:
                     if spec and spec.loader:
                         module = importlib.util.module_from_spec(spec)
                         spec.loader.exec_module(module)
+                        print(f"[CLAUDE_SKILLS]  Loaded module: {py_file.name}")
                         return module
+
+            # If no Python files found, return the skill directory info
+            # This allows skills to be registered even without Python implementation
+            print(f"[CLAUDE_SKILLS]  No Python files found, registering skill directory")
+            return {'type': 'directory', 'path': skill_dir}
+
         except Exception as e:
             print(f"[CLAUDE_SKILLS] Failed to load skill {skill_dir.name}: {e}")
         return None
@@ -127,13 +148,25 @@ class ClaudeSkillsHook:
                 content = skill_md.read_text(encoding='utf-8')
                 metadata = {}
 
-                for line in content.split('\\n'):
-                    if line.startswith('## Description:'):
-                        metadata['description'] = line.replace('## Description:', '').strip()
-                    elif line.startswith('## Usage:'):
-                        metadata['usage'] = line.replace('## Usage:', '').strip()
-                    elif line.startswith('## Location:'):
-                        metadata['location'] = line.replace('## Location:', '').strip()
+                # Parse YAML-style frontmatter
+                lines = content.split('\\n')
+                in_frontmatter = False
+                for line in lines:
+                    if line.strip() == '---':
+                        in_frontmatter = not in_frontmatter
+                        continue
+                    if in_frontmatter:
+                        if ':' in line:
+                            key, value = line.split(':', 1)
+                            metadata[key.strip()] = value.strip()
+                    else:
+                        # Fallback to old format
+                        if line.startswith('## Description:'):
+                            metadata['description'] = line.replace('## Description:', '').strip()
+                        elif line.startswith('## Usage:'):
+                            metadata['usage'] = line.replace('## Usage:', '').strip()
+                        elif line.startswith('## Location:'):
+                            metadata['location'] = line.replace('## Location:', '').strip()
 
                 return metadata
         except Exception as e:
@@ -226,8 +259,8 @@ __all__ = ['on_prompt', 'initialize']
   generateGeminiSkillsIntegration(projectPath, skillsDir) {
     return `// Gemini CLI Skills Integration Extension
 // Auto-generated by Stigmergy CLI v1.2.1
-// Project: ${projectPath}
-// Skills Directory: ${skillsDir}
+// Project: ${projectPath.replace(/\\/g, '/')}
+// Skills Directory: ${skillsDir.replace(/\\/g, '/')}
 
 const fs = require('fs');
 const path = require('path');
@@ -235,7 +268,7 @@ const os = require('os');
 
 class GeminiSkillsExtension {
   constructor() {
-    this.skillsDir = path.join('${skillsDir.replace(/\\/g, '\\\\')}');
+    this.skillsDir = path.join('${skillsDir.replace(/\\/g, '/')}');
     this.loadedSkills = new Map();
     this.skillMetadata = new Map();
   }
@@ -280,6 +313,27 @@ class GeminiSkillsExtension {
 
   async loadSkill(skillPath) {
     try {
+      // Check for skill implementation files in scripts subdirectory
+      const scriptsDir = path.join(skillPath, 'scripts');
+      if (fs.existsSync(scriptsDir) && fs.statSync(scriptsDir).isDirectory()) {
+        const jsFiles = fs.readdirSync(scriptsDir).filter(file => file.endsWith('.js'));
+
+        for (const jsFile of jsFiles) {
+          if (!jsFile.includes('test')) {
+            const skillModulePath = path.join(scriptsDir, jsFile);
+            try {
+              delete require.cache[require.resolve(skillModulePath)];
+              const skillModule = require(skillModulePath);
+              console.log(\`[GEMINI_SKILLS]  Loaded module: \${jsFile}\`);
+              return skillModule;
+            } catch (moduleError) {
+              console.warn(\`[GEMINI_SKILLS] Could not load module \${jsFile}: \${moduleError.message}\`);
+            }
+          }
+        }
+      }
+
+      // Fallback: check for JavaScript files in root directory
       const jsFiles = fs.readdirSync(skillPath).filter(file => file.endsWith('.js'));
 
       for (const jsFile of jsFiles) {
@@ -288,12 +342,18 @@ class GeminiSkillsExtension {
           try {
             delete require.cache[require.resolve(skillModulePath)];
             const skillModule = require(skillModulePath);
+            console.log(\`[GEMINI_SKILLS]  Loaded module: \${jsFile}\`);
             return skillModule;
           } catch (moduleError) {
             console.warn(\`[GEMINI_SKILLS] Could not load module \${jsFile}: \${moduleError.message}\`);
           }
         }
       }
+
+      // If no JavaScript files found, return skill directory info
+      console.log(\`[GEMINI_SKILLS]  No JavaScript files found, registering skill directory\`);
+      return { type: 'directory', path: skillPath };
+
     } catch (error) {
       console.error(\`[GEMINI_SKILLS] Failed to load skill from \${skillPath}:\`, error);
     }
@@ -454,8 +514,8 @@ if (typeof geminiCLI !== 'undefined') {
   generateQwenSkillsIntegration(projectPath, skillsDir) {
     return `// Qwen CLI Skills Integration Hook
 // Auto-generated by Stigmergy CLI v1.2.1
-// Project: ${projectPath}
-// Skills Directory: ${skillsDir}
+// Project: ${projectPath.replace(/\\/g, '/')}
+// Skills Directory: ${skillsDir.replace(/\\/g, '/')}
 
 const fs = require('fs');
 const path = require('path');
@@ -463,7 +523,7 @@ const path = require('path');
 class QwenSkillsHook {
   constructor() {
     this.toolName = 'qwen';
-    this.skillsDir = path.join('${skillsDir.replace(/\\/g, '\\\\')}');
+    this.skillsDir = path.join('${skillsDir.replace(/\\/g, '/')}');
     this.loadedSkills = new Map();
   }
 
@@ -503,6 +563,25 @@ class QwenSkillsHook {
 
   async loadSkill(skillPath) {
     try {
+      // Check for skill implementation files in scripts subdirectory
+      const scriptsDir = path.join(skillPath, 'scripts');
+      if (fs.existsSync(scriptsDir) && fs.statSync(scriptsDir).isDirectory()) {
+        const files = fs.readdirSync(scriptsDir);
+        const jsFiles = files.filter(file => file.endsWith('.js') && !file.includes('test'));
+
+        for (const jsFile of jsFiles) {
+          const skillModulePath = path.join(scriptsDir, jsFile);
+          try {
+            const skillModule = require(skillModulePath);
+            console.log(\`[QWEN_SKILLS]  Loaded module: \${jsFile}\`);
+            return skillModule;
+          } catch (moduleError) {
+            console.warn(\`[QWEN_SKILLS] Could not load \${jsFile}: \${moduleError.message}\`);
+          }
+        }
+      }
+
+      // Fallback: check for JavaScript files in root directory
       const files = fs.readdirSync(skillPath);
       const jsFiles = files.filter(file => file.endsWith('.js') && !file.includes('test'));
 
@@ -510,11 +589,17 @@ class QwenSkillsHook {
         const skillModulePath = path.join(skillPath, jsFile);
         try {
           const skillModule = require(skillModulePath);
+          console.log(\`[QWEN_SKILLS]  Loaded module: \${jsFile}\`);
           return skillModule;
         } catch (moduleError) {
           console.warn(\`[QWEN_SKILLS] Could not load \${jsFile}: \${moduleError.message}\`);
         }
       }
+
+      // If no JavaScript files found, return skill directory info
+      console.log(\`[QWEN_SKILLS]  No JavaScript files found, registering skill directory\`);
+      return { type: 'directory', path: skillPath };
+
     } catch (error) {
       console.error(\`[QWEN_SKILLS] Failed to load skill from \${skillPath}:\`, error);
     }
@@ -618,8 +703,8 @@ module.exports = QwenSkillsHook;
   generateCodeBuddySkillsIntegration(projectPath, skillsDir) {
     return `// CodeBuddy CLI Skills Integration
 // Auto-generated by Stigmergy CLI v1.2.1
-// Project: ${projectPath}
-// Skills Directory: ${skillsDir}
+// Project: ${projectPath.replace(/\\/g, '/')}
+// Skills Directory: ${skillsDir.replace(/\\/g, '/')}
 
 const fs = require('fs');
 const path = require('path');
@@ -627,7 +712,7 @@ const path = require('path');
 class CodeBuddySkillsIntegration {
   constructor() {
     this.toolName = 'codebuddy';
-    this.skillsDir = path.join('${skillsDir.replace(/\\/g, '\\\\')}');
+    this.skillsDir = path.join('${skillsDir.replace(/\\/g, '/')}');
     this.loadedSkills = new Map();
   }
 
@@ -667,6 +752,25 @@ class CodeBuddySkillsIntegration {
 
   async loadSkill(skillPath) {
     try {
+      // Check for skill implementation files in scripts subdirectory
+      const scriptsDir = path.join(skillPath, 'scripts');
+      if (fs.existsSync(scriptsDir) && fs.statSync(scriptsDir).isDirectory()) {
+        const files = fs.readdirSync(scriptsDir);
+        const jsFiles = files.filter(file => file.endsWith('.js') && !file.includes('test'));
+
+        for (const jsFile of jsFiles) {
+          const skillModulePath = path.join(scriptsDir, jsFile);
+          try {
+            const skillModule = require(skillModulePath);
+            console.log(\`[CODEBUDDY_SKILLS]  Loaded module: \${jsFile}\`);
+            return skillModule;
+          } catch (moduleError) {
+            console.warn(\`[CODEBUDDY_SKILLS] Could not load \${jsFile}: \${moduleError.message}\`);
+          }
+        }
+      }
+
+      // Fallback: check for JavaScript files in root directory
       const files = fs.readdirSync(skillPath);
       const jsFiles = files.filter(file => file.endsWith('.js') && !file.includes('test'));
 
@@ -674,11 +778,17 @@ class CodeBuddySkillsIntegration {
         const skillModulePath = path.join(skillPath, jsFile);
         try {
           const skillModule = require(skillModulePath);
+          console.log(\`[CODEBUDDY_SKILLS]  Loaded module: \${jsFile}\`);
           return skillModule;
         } catch (moduleError) {
           console.warn(\`[CODEBUDDY_SKILLS] Could not load \${jsFile}: \${moduleError.message}\`);
         }
       }
+
+      // If no JavaScript files found, return skill directory info
+      console.log(\`[CODEBUDDY_SKILLS]  No JavaScript files found, registering skill directory\`);
+      return { type: 'directory', path: skillPath };
+
     } catch (error) {
       console.error(\`[CODEBUDDY_SKILLS] Failed to load skill from \${skillPath}:\`, error);
     }
@@ -781,8 +891,8 @@ module.exports = CodeBuddySkillsIntegration;
   generateCodexSkillsIntegration(projectPath, skillsDir) {
     return `// Codex CLI Skills Integration Handler
 // Auto-generated by Stigmergy CLI v1.2.1
-// Project: ${projectPath}
-// Skills Directory: ${skillsDir}
+// Project: ${projectPath.replace(/\\/g, '/')}
+// Skills Directory: ${skillsDir.replace(/\\/g, '/')}
 
 const fs = require('fs');
 const path = require('path');
@@ -790,7 +900,7 @@ const path = require('path');
 class CodexSkillsHandler {
   constructor() {
     this.toolName = 'codex';
-    this.skillsDir = path.join('${skillsDir.replace(/\\/g, '\\\\')}');
+    this.skillsDir = path.join('${skillsDir.replace(/\\/g, '/')}');
     this.loadedSkills = new Map();
   }
 
@@ -830,6 +940,25 @@ class CodexSkillsHandler {
 
   async loadSkill(skillPath) {
     try {
+      // Check for skill implementation files in scripts subdirectory
+      const scriptsDir = path.join(skillPath, 'scripts');
+      if (fs.existsSync(scriptsDir) && fs.statSync(scriptsDir).isDirectory()) {
+        const files = fs.readdirSync(scriptsDir);
+        const jsFiles = files.filter(file => file.endsWith('.js') && !file.includes('test'));
+
+        for (const jsFile of jsFiles) {
+          const skillModulePath = path.join(scriptsDir, jsFile);
+          try {
+            const skillModule = require(skillModulePath);
+            console.log(\`[CODEX_SKILLS]  Loaded module: \${jsFile}\`);
+            return skillModule;
+          } catch (moduleError) {
+            console.warn(\`[CODEX_SKILLS] Could not load \${jsFile}: \${moduleError.message}\`);
+          }
+        }
+      }
+
+      // Fallback: check for JavaScript files in root directory
       const files = fs.readdirSync(skillPath);
       const jsFiles = files.filter(file => file.endsWith('.js') && !file.includes('test'));
 
@@ -837,11 +966,17 @@ class CodexSkillsHandler {
         const skillModulePath = path.join(skillPath, jsFile);
         try {
           const skillModule = require(skillModulePath);
+          console.log(\`[CODEX_SKILLS]  Loaded module: \${jsFile}\`);
           return skillModule;
         } catch (moduleError) {
           console.warn(\`[CODEX_SKILLS] Could not load \${jsFile}: \${moduleError.message}\`);
         }
       }
+
+      // If no JavaScript files found, return skill directory info
+      console.log(\`[CODEX_SKILLS]  No JavaScript files found, registering skill directory\`);
+      return { type: 'directory', path: skillPath };
+
     } catch (error) {
       console.error(\`[CODEX_SKILLS] Failed to load skill from \${skillPath}:\`, error);
     }
@@ -945,8 +1080,8 @@ module.exports = CodexSkillsHandler;
   generateQoderCliSkillsIntegration(projectPath, skillsDir) {
     return `// QoderCLI Skills Integration Extension
 // Auto-generated by Stigmergy CLI v1.2.1
-// Project: ${projectPath}
-// Skills Directory: ${skillsDir}
+// Project: ${projectPath.replace(/\\/g, '/')}
+// Skills Directory: ${skillsDir.replace(/\\/g, '/')}
 
 const fs = require('fs');
 const path = require('path');
@@ -954,7 +1089,7 @@ const path = require('path');
 class QoderCliSkillsExtension {
   constructor() {
     this.toolName = 'qodercli';
-    this.skillsDir = path.join('${skillsDir.replace(/\\/g, '\\\\')}');
+    this.skillsDir = path.join('${skillsDir.replace(/\\/g, '/')}');
     this.loadedSkills = new Map();
   }
 
@@ -994,6 +1129,25 @@ class QoderCliSkillsExtension {
 
   async loadSkill(skillPath) {
     try {
+      // Check for skill implementation files in scripts subdirectory
+      const scriptsDir = path.join(skillPath, 'scripts');
+      if (fs.existsSync(scriptsDir) && fs.statSync(scriptsDir).isDirectory()) {
+        const files = fs.readdirSync(scriptsDir);
+        const jsFiles = files.filter(file => file.endsWith('.js') && !file.includes('test'));
+
+        for (const jsFile of jsFiles) {
+          const skillModulePath = path.join(scriptsDir, jsFile);
+          try {
+            const skillModule = require(skillModulePath);
+            console.log(\`[QODERCLI_SKILLS]  Loaded module: \${jsFile}\`);
+            return skillModule;
+          } catch (moduleError) {
+            console.warn(\`[QODERCLI_SKILLS] Could not load \${jsFile}: \${moduleError.message}\`);
+          }
+        }
+      }
+
+      // Fallback: check for JavaScript files in root directory
       const files = fs.readdirSync(skillPath);
       const jsFiles = files.filter(file => file.endsWith('.js') && !file.includes('test'));
 
@@ -1001,11 +1155,17 @@ class QoderCliSkillsExtension {
         const skillModulePath = path.join(skillPath, jsFile);
         try {
           const skillModule = require(skillModulePath);
+          console.log(\`[QODERCLI_SKILLS]  Loaded module: \${jsFile}\`);
           return skillModule;
         } catch (moduleError) {
           console.warn(\`[QODERCLI_SKILLS] Could not load \${jsFile}: \${moduleError.message}\`);
         }
       }
+
+      // If no JavaScript files found, return skill directory info
+      console.log(\`[QODERCLI_SKILLS]  No JavaScript files found, registering skill directory\`);
+      return { type: 'directory', path: skillPath };
+
     } catch (error) {
       console.error(\`[QODERCLI_SKILLS] Failed to load skill from \${skillPath}:\`, error);
     }
@@ -1109,8 +1269,8 @@ module.exports = QoderCliSkillsExtension;
 
     return `// ${className}
 // Auto-generated by Stigmergy CLI v1.2.1
-// Project: ${projectPath}
-// Skills Directory: ${skillsDir}
+// Project: ${projectPath.replace(/\\/g, '/')}
+// Skills Directory: ${skillsDir.replace(/\\/g, '/')}
 
 const fs = require('fs');
 const path = require('path');
@@ -1118,7 +1278,7 @@ const path = require('path');
 class ${className} {
   constructor() {
     this.toolName = '${cliName}';
-    this.skillsDir = path.join('${skillsDir.replace(/\\/g, '\\\\')}');
+    this.skillsDir = path.join('${skillsDir.replace(/\\/g, '/')}');
     this.loadedSkills = new Map();
   }
 
@@ -1158,6 +1318,25 @@ class ${className} {
 
   async loadSkill(skillPath) {
     try {
+      // Check for skill implementation files in scripts subdirectory
+      const scriptsDir = path.join(skillPath, 'scripts');
+      if (fs.existsSync(scriptsDir) && fs.statSync(scriptsDir).isDirectory()) {
+        const files = fs.readdirSync(scriptsDir);
+        const jsFiles = files.filter(file => file.endsWith('.js') && !file.includes('test'));
+
+        for (const jsFile of jsFiles) {
+          const skillModulePath = path.join(scriptsDir, jsFile);
+          try {
+            const skillModule = require(skillModulePath);
+            console.log(\`[\${this.toolName.toUpperCase()}_SKILLS]  Loaded module: \${jsFile}\`);
+            return skillModule;
+          } catch (moduleError) {
+            console.warn(\`[\${this.toolName.toUpperCase()}_SKILLS] Could not load \${jsFile}: \${moduleError.message}\`);
+          }
+        }
+      }
+
+      // Fallback: check for JavaScript files in root directory
       const files = fs.readdirSync(skillPath);
       const jsFiles = files.filter(file => file.endsWith('.js') && !file.includes('test'));
 
@@ -1165,11 +1344,17 @@ class ${className} {
         const skillModulePath = path.join(skillPath, jsFile);
         try {
           const skillModule = require(skillModulePath);
+          console.log(\`[\${this.toolName.toUpperCase()}_SKILLS]  Loaded module: \${jsFile}\`);
           return skillModule;
         } catch (moduleError) {
           console.warn(\`[\${this.toolName.toUpperCase()}_SKILLS] Could not load \${jsFile}: \${moduleError.message}\`);
         }
       }
+
+      // If no JavaScript files found, return skill directory info
+      console.log(\`[\${this.toolName.toUpperCase()}_SKILLS]  No JavaScript files found, registering skill directory\`);
+      return { type: 'directory', path: skillPath };
+
     } catch (error) {
       console.error(\`[\${this.toolName.toUpperCase()}_SKILLS] Failed to load skill from \${skillPath}:\`, error);
     }

package/src/core/enhanced_cli_installer.js

@@ -465,6 +465,31 @@ class EnhancedCLIInstaller {
         };
       }
 
+      // Check if tool requires bun runtime
+      if (toolInfo.requiresBun) {
+        const bunAvailable = await this.checkBunAvailable();
+        if (!bunAvailable) {
+          this.log('warn', `${toolInfo.name} requires bun, but bun is not installed`);
+          this.log('info', `Installing bun first...`);
+
+          const bunResult = await this.executeInstallationCommand('npm install bun -g');
+
+          if (!bunResult.success) {
+            return {
+              success: false,
+              error: `Failed to install bun (required for ${toolInfo.name}): ${bunResult.error}`
+            };
+          }
+
+          this.log('success', 'Bun installed successfully');
+        }
+      }
+
+      // Check if install command contains multiple steps (&&)
+      if (toolInfo.install.includes('&&')) {
+        return await this.executeMultiStepInstallation(toolInfo);
+      }
+
       const [command, ...args] = toolInfo.install.split(' ');
 
       this.log('debug', `Executing: ${toolInfo.install}`);
@@ -1089,6 +1114,96 @@ class EnhancedCLIInstaller {
       details: installations
     };
   }
+
+  /**
+   * Check if bun runtime is available
+   * @returns {Promise<boolean>} True if bun is available
+   */
+  async checkBunAvailable() {
+    const { spawnSync } = require('child_process');
+
+    try {
+      const result = spawnSync('bun', ['--version'], {
+        stdio: 'pipe',
+        shell: true
+      });
+
+      return result.status === 0 || result.error === undefined;
+    } catch (error) {
+      return false;
+    }
+  }
+
+  /**
+   * Execute multi-step installation (commands with &&)
+   * @param {Object} toolInfo - Tool information
+   * @returns {Promise<Object>} Installation result
+   */
+  async executeMultiStepInstallation(toolInfo) {
+    const steps = toolInfo.install.split('&&').map(s => s.trim());
+
+    this.log('info', `Executing multi-step installation (${steps.length} steps) for ${toolInfo.name}...`);
+
+    for (let i = 0; i < steps.length; i++) {
+      const step = steps[i];
+      const stepNumber = i + 1;
+
+      this.log('info', `Step ${stepNumber}/${steps.length}: ${step}`);
+
+      const result = await this.executeInstallationCommand(step);
+
+      if (!result.success) {
+        this.log('error', `Step ${stepNumber} failed: ${result.error}`);
+        return {
+          success: false,
+          error: `Installation failed at step ${stepNumber}: ${result.error}`,
+          failedAtStep: stepNumber,
+          failedCommand: step
+        };
+      }
+
+      this.log('success', `Step ${stepNumber}/${steps.length} completed`);
+    }
+
+    this.log('success', `All ${steps.length} steps completed successfully for ${toolInfo.name}`);
+
+    return {
+      success: true,
+      stepsCompleted: steps.length
+    };
+  }
+
+  /**
+   * Execute a single installation command
+   * @param {string} command - Installation command
+   * @returns {Promise<Object>} Execution result
+   */
+  async executeInstallationCommand(command) {
+    const { executeCommand } = require('../utils');
+
+    try {
+      const result = await executeCommand(command, [], {
+        stdio: this.verbose ? 'inherit' : 'pipe',
+        shell: true,
+        timeout: 300000 // 5 minutes
+      });
+
+      if (result.success) {
+        return { success: true };
+      } else {
+        return {
+          success: false,
+          error: result.error || `Command exited with code ${result.code}`,
+          code: result.code
+        };
+      }
+    } catch (error) {
+      return {
+        success: false,
+        error: error.message
+      };
+    }
+  }
 }
 
 module.exports = EnhancedCLIInstaller;

package/src/core/skills/StigmergySkillManager.js

@@ -121,11 +121,11 @@ export class StigmergySkillManager {
 
     /**
      * Sync skills to CLI configuration files
-     * Also refreshes the LocalSkillScanner cache
+     * 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
@@ -152,10 +152,14 @@ export class StigmergySkillManager {
                 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
@@ -165,7 +169,9 @@ 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;
@@ -191,19 +197,102 @@ export class StigmergySkillManager {
 
             // 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;
     }
 
     /**