@geekbeer/minion 3.16.1 → 3.22.0

package/core/routes/skills.js

@@ -19,6 +19,8 @@ const api = require('../api')
 const { config, isHqConfigured } = require('../config')
 const executionStore = require('../stores/execution-store')
 const logManager = require('../lib/log-manager')
+const { reportDagNodeComplete } = require('../lib/dag-node-executor')
+const { getActiveSkillDirs, getPrimarySkillDir } = require('../llm-plugins/lib/skill-dirs')
 
 /**
  * Parse YAML frontmatter from SKILL.md content
@@ -40,8 +42,12 @@ function parseFrontmatter(content) {
 }
 
 /**
- * Write a skill to the local ~/.claude/skills/ directory.
- * Shared by deploy-skill and skills/fetch endpoints.
+ * Write a skill to the local skill directories of all enabled LLM plugins.
+ *
+ * Multi-plugin distribution: each LLM CLI loads skills from its own dir
+ * (e.g. ~/.claude/skills/, ~/.gemini/skills/). The same skill content is
+ * written to every enabled plugin's directory so switching Primary doesn't
+ * break skill availability.
  *
  * @param {string} name - Skill slug (e.g. "execution-report")
  * @param {object} opts
@@ -49,15 +55,9 @@ function parseFrontmatter(content) {
  * @param {string} [opts.description] - Skill description for frontmatter
  * @param {string} [opts.display_name] - Display name for frontmatter
  * @param {Array<{path: string, content?: string}>} [opts.files] - Skill files from HQ storage
- * @returns {Promise<{path: string, files_count: number}>}
+ * @returns {Promise<{path: string, paths: string[], files_count: number}>}
  */
 async function writeSkillToLocal(name, { content, description, display_name, type, files = [] }) {
-  const skillDir = path.join(config.HOME_DIR, '.claude', 'skills', name)
-  const filesDir = path.join(skillDir, 'files')
-
-  await fs.mkdir(skillDir, { recursive: true })
-  await fs.mkdir(filesDir, { recursive: true })
-
   // If content already has frontmatter, write as-is; otherwise build frontmatter
   const hasFrontmatter = content.startsWith('---\n')
   let fileContent
@@ -73,21 +73,30 @@ async function writeSkillToLocal(name, { content, description, display_name, typ
     fileContent = `---\n${frontmatterLines}\n---\n\n${content}`
   }
 
-  await fs.writeFile(
-    path.join(skillDir, 'SKILL.md'),
-    fileContent,
-    'utf-8'
-  )
-
-  // Write skill files
-  for (const file of files) {
-    if (file.path && file.content) {
-      const safeFilename = path.basename(file.path)
-      await fs.writeFile(path.join(filesDir, safeFilename), file.content, 'utf-8')
+  const targetRoots = getActiveSkillDirs()
+  const writtenPaths = []
+
+  for (const root of targetRoots) {
+    const skillDir = path.join(root, name)
+    const filesDir = path.join(skillDir, 'files')
+    await fs.mkdir(skillDir, { recursive: true })
+    await fs.mkdir(filesDir, { recursive: true })
+    await fs.writeFile(path.join(skillDir, 'SKILL.md'), fileContent, 'utf-8')
+
+    for (const file of files) {
+      if (file.path && file.content) {
+        const safeFilename = path.basename(file.path)
+        await fs.writeFile(path.join(filesDir, safeFilename), file.content, 'utf-8')
+      }
     }
+    writtenPaths.push(skillDir)
   }
 
-  return { path: skillDir, files_count: files.length }
+  return {
+    path: writtenPaths[0],
+    paths: writtenPaths,
+    files_count: files.length,
+  }
 }
 
 /**
@@ -99,8 +108,10 @@ async function writeSkillToLocal(name, { content, description, display_name, typ
  * @throws {Error} If skill not found locally or HQ rejects
  */
 async function pushSkillToHQ(name) {
-  const homeDir = config.HOME_DIR
-  const skillDir = path.join(homeDir, '.claude', 'skills', name)
+  // Use the Primary plugin's skill directory as the canonical read source.
+  // Skills are written identically to every enabled plugin dir, so reading
+  // from any one of them yields the same content.
+  const skillDir = path.join(getPrimarySkillDir(), name)
   const skillMdPath = path.join(skillDir, 'SKILL.md')
 
   const rawContent = await fs.readFile(skillMdPath, 'utf-8')
@@ -158,34 +169,29 @@ async function skillRoutes(fastify, opts) {
     console.log('[Skills] Listing deployed skills')
 
     try {
-      const homeDir = config.HOME_DIR
-      const skillsDir = path.join(homeDir, '.claude', 'skills')
-
-      // Check if skills directory exists
-      try {
-        await fs.access(skillsDir)
-      } catch {
-        // Directory doesn't exist, return empty list
-        console.log('[Skills] Skills directory does not exist, returning empty list')
-        return { success: true, skills: [] }
-      }
-
-      // Read directory contents
-      const entries = await fs.readdir(skillsDir, { withFileTypes: true })
-
-      // Filter to only directories that contain SKILL.md
-      const skills = []
-      for (const entry of entries) {
-        if (entry.isDirectory()) {
+      // Union of skills across all active plugin skill dirs.
+      // Same skill name may exist in multiple dirs (multi-plugin distribution);
+      // dedupe via Set.
+      const skillsSet = new Set()
+      for (const skillsDir of getActiveSkillDirs()) {
+        try {
+          await fs.access(skillsDir)
+        } catch {
+          continue
+        }
+        const entries = await fs.readdir(skillsDir, { withFileTypes: true })
+        for (const entry of entries) {
+          if (!entry.isDirectory()) continue
           const skillMdPath = path.join(skillsDir, entry.name, 'SKILL.md')
           try {
             await fs.access(skillMdPath)
-            skills.push(entry.name)
+            skillsSet.add(entry.name)
           } catch {
-            // SKILL.md doesn't exist, skip this directory
+            // SKILL.md missing, skip
           }
         }
       }
+      const skills = [...skillsSet]
 
       console.log(`[Skills] Found ${skills.length} deployed skills: ${skills.join(', ') || '(none)'}`)
 
@@ -311,16 +317,23 @@ async function skillRoutes(fastify, opts) {
       return { success: false, error: 'Unauthorized' }
     }
 
-    const { skill_name, execution_id, step_index, workflow_name, role, revision_feedback } = request.body || {}
+    const {
+      skill_name,
+      execution_id,
+      step_index,
+      workflow_name,
+      role,
+      revision_feedback,
+      dag_node_execution_id,
+    } = request.body || {}
 
     if (!skill_name) {
       reply.code(400)
       return { success: false, error: 'skill_name is required' }
     }
 
-    // Verify skill exists locally
-    const homeDir = config.HOME_DIR
-    const skillMdPath = path.join(homeDir, '.claude', 'skills', skill_name, 'SKILL.md')
+    // Verify skill exists locally (any plugin's dir is sufficient)
+    const skillMdPath = path.join(getPrimarySkillDir(), skill_name, 'SKILL.md')
     try {
       await fs.access(skillMdPath)
     } catch {
@@ -419,6 +432,44 @@ async function skillRoutes(fastify, opts) {
             console.error(`[Skills] Failed to report step completion: ${hookErr.message}`)
           }
         }
+
+        // Post-execution hook: report DAG node completion to HQ
+        if (dag_node_execution_id) {
+          try {
+            let summary = null
+            let details = null
+            try {
+              const execRecord = await executionStore.getById(effectiveExecutionId)
+              if (execRecord) {
+                summary = execRecord.summary || null
+                details = execRecord.details || null
+              }
+            } catch (readErr) {
+              console.error(`[Skills] Failed to read execution report for DAG node: ${readErr.message}`)
+            }
+
+            await reportDagNodeComplete(
+              dag_node_execution_id,
+              success ? 'completed' : 'failed',
+              summary,
+              details
+            )
+            console.log(`[Skills] DAG node completion reported: ${dag_node_execution_id} → ${success ? 'completed' : 'failed'}`)
+          } catch (hookErr) {
+            console.error(`[Skills] Failed to report DAG node completion: ${hookErr.message}`)
+          }
+
+          // Clean up ephemeral transform skill directory (created by dag-step-poller)
+          if (skill_name.startsWith('_dag_transform_')) {
+            for (const root of getActiveSkillDirs()) {
+              try {
+                await fs.rm(path.join(root, skill_name), { recursive: true, force: true })
+              } catch {
+                // best-effort cleanup
+              }
+            }
+          }
+        }
       }
     })()
 
@@ -458,20 +509,24 @@ async function skillRoutes(fastify, opts) {
     console.log(`[Skills] Deleting skill: ${name}`)
 
     try {
-      const homeDir = config.HOME_DIR
-      const skillDir = path.join(homeDir, '.claude', 'skills', name)
+      // Delete from every active plugin's skill dir
+      let foundAny = false
+      for (const root of getActiveSkillDirs()) {
+        const skillDir = path.join(root, name)
+        try {
+          await fs.access(skillDir)
+          await fs.rm(skillDir, { recursive: true, force: true })
+          foundAny = true
+        } catch {
+          // not present in this dir
+        }
+      }
 
-      // Check if skill exists
-      try {
-        await fs.access(skillDir)
-      } catch {
+      if (!foundAny) {
         reply.code(404)
         return { success: false, error: 'Skill not found' }
       }
 
-      // Recursively delete the skill directory
-      await fs.rm(skillDir, { recursive: true, force: true })
-
       console.log(`[Skills] Skill deleted successfully: ${name}`)
 
       return {