@ian2018cs/agenthub 0.1.25 → 0.1.27

package/server/routes/skills.js

@@ -29,31 +29,24 @@ const upload = multer({
 });
 
 /**
- * Parse skill metadata from SKILLS.md file
+ * Parse skill metadata from SKILL.md YAML frontmatter
  */
 async function parseSkillMetadata(skillPath) {
   try {
-    const skillsFile = path.join(skillPath, 'SKILLS.md');
+    const skillsFile = path.join(skillPath, 'SKILL.md');
     const content = await fs.readFile(skillsFile, 'utf-8');
 
-    // Extract title from first # heading
-    const titleMatch = content.match(/^#\s+(.+)$/m);
-    const title = titleMatch ? titleMatch[1].trim() : path.basename(skillPath);
-
-    // Extract description from content after title (first paragraph)
-    const lines = content.split('\n');
+    let title = path.basename(skillPath);
     let description = '';
-    let foundTitle = false;
-    for (const line of lines) {
-      if (line.startsWith('#')) {
-        if (foundTitle) break;
-        foundTitle = true;
-        continue;
-      }
-      if (foundTitle && line.trim()) {
-        description = line.trim();
-        break;
-      }
+
+    // Parse YAML frontmatter (between --- delimiters)
+    const fmMatch = content.match(/^---\s*\n([\s\S]*?)\n---/);
+    if (fmMatch) {
+      const fm = fmMatch[1];
+      const nameMatch = fm.match(/^name:\s*(.+)$/m);
+      const descMatch = fm.match(/^description:\s*(.+)$/m);
+      if (nameMatch) title = nameMatch[1].trim();
+      if (descMatch) description = descMatch[1].trim();
     }
 
     return { title, description };
@@ -63,27 +56,64 @@ async function parseSkillMetadata(skillPath) {
 }
 
 /**
- * Check if a path is a valid skill directory
+ * Check if a path is a valid skill directory (must contain SKILL.md)
  */
 async function isValidSkill(skillPath) {
   try {
     const stat = await fs.stat(skillPath);
     if (!stat.isDirectory()) return false;
 
-    // Check for SKILLS.md
-    try {
-      await fs.access(path.join(skillPath, 'SKILLS.md'));
-      return true;
-    } catch {
-      // Fallback: check for any .md files
-      const files = await fs.readdir(skillPath);
-      return files.some(f => f.endsWith('.md'));
-    }
+    await fs.access(path.join(skillPath, 'SKILL.md'));
+    return true;
   } catch {
     return false;
   }
 }
 
+/**
+ * Recursively scan a directory for valid skill subdirectories.
+ * Supports nested structures like skills/XXX (maxDepth controls recursion depth).
+ * If a directory is itself a valid skill it is collected and not recursed into.
+ */
+async function scanDirForSkills(dirPath, repository, installedSkills, maxDepth = 2) {
+  const found = [];
+
+  let entries;
+  try {
+    entries = await fs.readdir(dirPath, { withFileTypes: true });
+  } catch {
+    return found;
+  }
+
+  for (const entry of entries) {
+    if (entry.name.startsWith('.') ||
+        entry.name.toLowerCase().startsWith('readme') ||
+        !entry.isDirectory()) {
+      continue;
+    }
+
+    const skillPath = path.join(dirPath, entry.name);
+
+    if (await isValidSkill(skillPath)) {
+      const metadata = await parseSkillMetadata(skillPath);
+      found.push({
+        name: entry.name,
+        title: metadata.title,
+        description: metadata.description,
+        repository,
+        installed: installedSkills ? installedSkills.has(entry.name) : false,
+        path: skillPath
+      });
+    } else if (maxDepth > 0) {
+      // Not a skill itself — recurse into it looking for nested skills
+      const nested = await scanDirForSkills(skillPath, repository, installedSkills, maxDepth - 1);
+      found.push(...nested);
+    }
+  }
+
+  return found;
+}
+
 /**
  * Check if URL is SSH format (git@host:path)
  */
@@ -497,18 +527,18 @@ router.post('/import', upload.single('skillZip'), async (req, res) => {
     }
 
     // Determine skill name from zip structure
-    // Look for the root directory or first directory containing SKILLS.md
+    // Look for the root directory or first directory containing SKILL.md
     let skillName = null;
     let rootDir = '';
 
     for (const entry of zipEntries) {
-      if (entry.entryName.endsWith('SKILLS.md')) {
+      if (entry.entryName.endsWith('SKILL.md')) {
         const parts = entry.entryName.split('/');
         if (parts.length >= 2) {
           skillName = parts[0];
           rootDir = parts[0] + '/';
         } else {
-          // SKILLS.md is at root, use original zip filename
+          // SKILL.md is at root, use original zip filename
           skillName = path.basename(req.file.originalname, '.zip');
         }
         break;
@@ -638,34 +668,9 @@ router.get('/available', async (req, res) => {
             continue;
           }
 
-          // Scan for skills in the repo
-          const entries = await fs.readdir(realRepoPath, { withFileTypes: true });
-
-          for (const entry of entries) {
-            // Skip hidden dirs, READMEs, and files
-            if (entry.name.startsWith('.') ||
-                entry.name.toLowerCase().startsWith('readme') ||
-                !entry.isDirectory()) {
-              continue;
-            }
-
-            const skillPath = path.join(realRepoPath, entry.name);
-
-            if (!await isValidSkill(skillPath)) {
-              continue;
-            }
-
-            const metadata = await parseSkillMetadata(skillPath);
-
-            skills.push({
-              name: entry.name,
-              title: metadata.title,
-              description: metadata.description,
-              repository: `${owner}/${repo}`,
-              installed: installedSkills.has(entry.name),
-              path: skillPath
-            });
-          }
+          // Scan for skills in the repo (supports nested dirs like skills/XXX)
+          const repoSkills = await scanDirForSkills(realRepoPath, `${owner}/${repo}`, installedSkills);
+          skills.push(...repoSkills);
         }
       }
     } catch (err) {
@@ -778,19 +783,9 @@ router.get('/repos', async (req, res) => {
             continue;
           }
 
-          // Count skills in repo
-          let skillCount = 0;
-          try {
-            const entries = await fs.readdir(realPath, { withFileTypes: true });
-            for (const entry of entries) {
-              if (entry.name.startsWith('.') || !entry.isDirectory()) continue;
-              if (await isValidSkill(path.join(realPath, entry.name))) {
-                skillCount++;
-              }
-            }
-          } catch {
-            // Ignore
-          }
+          // Count skills in repo (supports nested dirs like skills/XXX)
+          const repoSkills = await scanDirForSkills(realPath, `${owner}/${repo}`, null);
+          const skillCount = repoSkills.length;
 
           repos.push({
             owner,
@@ -882,16 +877,11 @@ router.post('/repos', async (req, res) => {
 
     await fs.symlink(publicRepoPath, userRepoPath);
 
-    // Count skills
+    // Count skills (supports nested dirs like skills/XXX)
     let skillCount = 0;
     try {
-      const entries = await fs.readdir(publicRepoPath, { withFileTypes: true });
-      for (const entry of entries) {
-        if (entry.name.startsWith('.') || !entry.isDirectory()) continue;
-        if (await isValidSkill(path.join(publicRepoPath, entry.name))) {
-          skillCount++;
-        }
-      }
+      const repoSkills = await scanDirForSkills(publicRepoPath, `${owner}/${repo}`, null);
+      skillCount = repoSkills.length;
     } catch {
       // Ignore
     }
@@ -912,6 +902,68 @@ router.post('/repos', async (req, res) => {
   }
 });
 
+/**
+ * POST /api/skills/repos/refresh
+ * Pull latest updates for all user's skill repositories
+ */
+router.post('/repos/refresh', async (req, res) => {
+  try {
+    const userUuid = req.user?.uuid;
+    if (!userUuid) {
+      return res.status(401).json({ error: 'User authentication required' });
+    }
+
+    const userPaths = getUserPaths(userUuid);
+    const results = [];
+
+    try {
+      await fs.mkdir(userPaths.skillsRepoDir, { recursive: true });
+      const owners = await fs.readdir(userPaths.skillsRepoDir);
+
+      for (const owner of owners) {
+        if (owner.startsWith('.')) continue;
+
+        const ownerPath = path.join(userPaths.skillsRepoDir, owner);
+        const stat = await fs.stat(ownerPath);
+        if (!stat.isDirectory()) continue;
+
+        const repoNames = await fs.readdir(ownerPath);
+
+        for (const repo of repoNames) {
+          if (repo.startsWith('.')) continue;
+
+          const repoPath = path.join(ownerPath, repo);
+          let realPath = repoPath;
+
+          try {
+            const repoStat = await fs.lstat(repoPath);
+            if (repoStat.isSymbolicLink()) {
+              realPath = await fs.realpath(repoPath);
+            }
+          } catch {
+            continue;
+          }
+
+          try {
+            await updateRepository(realPath);
+            results.push({ owner, repo, status: 'updated' });
+          } catch (err) {
+            console.log(`Failed to update ${owner}/${repo}:`, err.message);
+            results.push({ owner, repo, status: 'failed', error: err.message });
+          }
+        }
+      }
+    } catch (err) {
+      console.error('Error refreshing repos:', err);
+    }
+
+    res.json({ success: true, results });
+  } catch (error) {
+    console.error('Error refreshing repos:', error);
+    res.status(500).json({ error: error.message });
+  }
+});
+
 /**
  * DELETE /api/skills/repos/:owner/:repo
  * Remove a skill repository (user's symlink only)