groove-dev 0.12.7 → 0.13.0

package/node_modules/@groove-dev/daemon/skills-registry.json

@@ -0,0 +1,233 @@
+[
+  {
+    "id": "frontend-design",
+    "name": "Frontend Design",
+    "description": "Create distinctive, production-grade frontend interfaces with high design quality. Avoids generic AI aesthetics.",
+    "author": "Anthropic",
+    "category": "design",
+    "tags": ["frontend", "ui", "css", "react", "design-system"],
+    "roles": ["frontend", "fullstack"],
+    "source": "claude-official",
+    "icon": "P"
+  },
+  {
+    "id": "code-review",
+    "name": "Code Review",
+    "description": "Comprehensive PR code review using parallel specialized agents. Checks CLAUDE.md compliance, bugs, git history, and previous PR comments.",
+    "author": "Anthropic",
+    "category": "quality",
+    "tags": ["review", "pr", "github", "quality"],
+    "roles": ["testing", "fullstack"],
+    "source": "claude-official",
+    "icon": "R"
+  },
+  {
+    "id": "security-guidance",
+    "name": "Security Guidance",
+    "description": "Security-focused development guidance. OWASP top 10, input validation, auth patterns, secrets management.",
+    "author": "Anthropic",
+    "category": "security",
+    "tags": ["security", "owasp", "auth", "validation"],
+    "roles": ["backend", "fullstack", "devops"],
+    "source": "claude-official",
+    "icon": "S"
+  },
+  {
+    "id": "claude-automation-recommender",
+    "name": "Automation Recommender",
+    "description": "Analyze a codebase and recommend Claude Code automations — hooks, subagents, skills, plugins, MCP servers.",
+    "author": "Anthropic",
+    "category": "devtools",
+    "tags": ["automation", "hooks", "plugins", "mcp", "setup"],
+    "roles": ["planner", "devops", "fullstack"],
+    "source": "claude-official",
+    "icon": "A"
+  },
+  {
+    "id": "claude-md-improver",
+    "name": "CLAUDE.md Improver",
+    "description": "Audit and improve CLAUDE.md files. Scans quality, evaluates against templates, makes targeted updates.",
+    "author": "Anthropic",
+    "category": "devtools",
+    "tags": ["claude-md", "project-config", "audit"],
+    "roles": ["planner", "fullstack"],
+    "source": "claude-official",
+    "icon": "C"
+  },
+  {
+    "id": "build-mcp-server",
+    "name": "Build MCP Server",
+    "description": "End-to-end MCP server development. Interrogates use case, picks deployment model, designs tools, hands off to specialized skills.",
+    "author": "Anthropic",
+    "category": "devtools",
+    "tags": ["mcp", "api", "integration", "tools"],
+    "roles": ["backend", "fullstack"],
+    "source": "claude-official",
+    "icon": "M"
+  },
+  {
+    "id": "build-mcp-app",
+    "name": "Build MCP App",
+    "description": "Add interactive UI widgets to MCP servers — forms, pickers, dashboards, confirmation dialogs inline in chat.",
+    "author": "Anthropic",
+    "category": "devtools",
+    "tags": ["mcp", "ui", "widgets", "apps-sdk"],
+    "roles": ["frontend", "fullstack"],
+    "source": "claude-official",
+    "icon": "U"
+  },
+  {
+    "id": "feature-dev",
+    "name": "Feature Development",
+    "description": "Guided feature development with codebase understanding and architecture focus. Structured workflow from research to implementation.",
+    "author": "Anthropic",
+    "category": "workflow",
+    "tags": ["feature", "architecture", "guided", "development"],
+    "roles": ["backend", "frontend", "fullstack"],
+    "source": "claude-official",
+    "icon": "F"
+  },
+  {
+    "id": "skill-creator",
+    "name": "Skill Creator",
+    "description": "Create new skills, modify existing ones, run evals, benchmark performance. The meta-skill for building skills.",
+    "author": "Anthropic",
+    "category": "devtools",
+    "tags": ["skills", "plugins", "meta", "evals"],
+    "roles": ["planner", "fullstack"],
+    "source": "claude-official",
+    "icon": "K"
+  },
+  {
+    "id": "plugin-structure",
+    "name": "Plugin Structure",
+    "description": "Scaffold and organize Claude Code plugins. Directory layout, manifest, components, auto-discovery patterns.",
+    "author": "Anthropic",
+    "category": "devtools",
+    "tags": ["plugins", "scaffold", "architecture"],
+    "roles": ["fullstack", "devops"],
+    "source": "claude-official",
+    "icon": "L"
+  },
+  {
+    "id": "hook-development",
+    "name": "Hook Development",
+    "description": "Create PreToolUse, PostToolUse, Stop hooks. Event-driven automation, tool validation, prompt-based hooks API.",
+    "author": "Anthropic",
+    "category": "devtools",
+    "tags": ["hooks", "automation", "events", "validation"],
+    "roles": ["devops", "fullstack"],
+    "source": "claude-official",
+    "icon": "H"
+  },
+  {
+    "id": "agent-development",
+    "name": "Agent Development",
+    "description": "Create subagents with system prompts, triggering conditions, tool access, and autonomous behavior patterns.",
+    "author": "Anthropic",
+    "category": "devtools",
+    "tags": ["agents", "subagents", "autonomous"],
+    "roles": ["planner", "fullstack"],
+    "source": "claude-official",
+    "icon": "G"
+  },
+  {
+    "id": "playground",
+    "name": "Playground Builder",
+    "description": "Create interactive HTML playgrounds — single-file explorers with live preview, visual controls, and copy-out prompts.",
+    "author": "Anthropic",
+    "category": "design",
+    "tags": ["playground", "interactive", "html", "demo"],
+    "roles": ["frontend", "docs"],
+    "source": "claude-official",
+    "icon": "Y"
+  },
+  {
+    "id": "math-olympiad",
+    "name": "Math Olympiad",
+    "description": "Advanced mathematical problem solving. Competition-level math, proofs, and formal reasoning.",
+    "author": "Anthropic",
+    "category": "specialized",
+    "tags": ["math", "proofs", "reasoning", "competition"],
+    "roles": [],
+    "source": "claude-official",
+    "icon": "X"
+  },
+  {
+    "id": "hookify",
+    "name": "Hookify",
+    "description": "Create hooks to prevent unwanted behaviors from conversation analysis or explicit instructions. Rule-based automation.",
+    "author": "Anthropic",
+    "category": "devtools",
+    "tags": ["hooks", "rules", "automation", "guardrails"],
+    "roles": ["devops", "fullstack"],
+    "source": "claude-official",
+    "icon": "I"
+  },
+  {
+    "id": "code-simplifier",
+    "name": "Code Simplifier",
+    "description": "Review changed code for reuse, quality, and efficiency. Identifies over-engineering and suggests simplifications.",
+    "author": "Anthropic",
+    "category": "quality",
+    "tags": ["refactor", "simplify", "quality", "efficiency"],
+    "roles": ["backend", "frontend", "fullstack"],
+    "source": "claude-official",
+    "icon": "Z"
+  },
+  {
+    "id": "commit-commands",
+    "name": "Commit Commands",
+    "description": "Git workflow commands — commit, push, open PR, clean gone branches. Structured commit messages.",
+    "author": "Anthropic",
+    "category": "workflow",
+    "tags": ["git", "commit", "pr", "workflow"],
+    "roles": ["fullstack", "backend", "frontend"],
+    "source": "claude-official",
+    "icon": "V"
+  },
+  {
+    "id": "pr-review-toolkit",
+    "name": "PR Review Toolkit",
+    "description": "Comprehensive PR review using specialized parallel agents. Multi-angle analysis with confidence scoring.",
+    "author": "Anthropic",
+    "category": "quality",
+    "tags": ["pr", "review", "github", "parallel-agents"],
+    "roles": ["testing", "fullstack"],
+    "source": "claude-official",
+    "icon": "T"
+  },
+  {
+    "id": "new-sdk-app",
+    "name": "Agent SDK Starter",
+    "description": "Create and setup a new Claude Agent SDK application. Scaffolds project structure and configuration.",
+    "author": "Anthropic",
+    "category": "devtools",
+    "tags": ["agent-sdk", "scaffold", "setup"],
+    "roles": ["backend", "fullstack"],
+    "source": "claude-official",
+    "icon": "N"
+  },
+  {
+    "id": "explanatory-output",
+    "name": "Explanatory Output",
+    "description": "Output style that explains reasoning and decisions. Teaches while building — great for learning and code review.",
+    "author": "Anthropic",
+    "category": "workflow",
+    "tags": ["output-style", "learning", "explanatory"],
+    "roles": [],
+    "source": "claude-official",
+    "icon": "E"
+  },
+  {
+    "id": "learning-output",
+    "name": "Learning Output",
+    "description": "Output style optimized for learning. Step-by-step explanations, concept breakdowns, guided understanding.",
+    "author": "Anthropic",
+    "category": "workflow",
+    "tags": ["output-style", "learning", "educational"],
+    "roles": [],
+    "source": "claude-official",
+    "icon": "W"
+  }
+]

package/node_modules/@groove-dev/daemon/src/api.js

@@ -365,6 +365,47 @@ export function createApi(app, daemon) {
     res.json(daemon.adaptive.getAllProfiles());
   });
 
+  // --- Skills Marketplace ---
+
+  app.get('/api/skills/registry', (req, res) => {
+    const skills = daemon.skills.getRegistry({
+      search: req.query.search || '',
+      category: req.query.category || 'all',
+    });
+    res.json({
+      skills,
+      categories: daemon.skills.getCategories(),
+    });
+  });
+
+  app.get('/api/skills/installed', (req, res) => {
+    res.json(daemon.skills.getInstalled());
+  });
+
+  app.post('/api/skills/:id/install', (req, res) => {
+    try {
+      const result = daemon.skills.install(req.params.id);
+      res.json(result);
+    } catch (err) {
+      res.status(400).json({ error: err.message });
+    }
+  });
+
+  app.delete('/api/skills/:id', (req, res) => {
+    try {
+      const result = daemon.skills.uninstall(req.params.id);
+      res.json(result);
+    } catch (err) {
+      res.status(400).json({ error: err.message });
+    }
+  });
+
+  app.get('/api/skills/:id/content', (req, res) => {
+    const content = daemon.skills.getContent(req.params.id);
+    if (!content) return res.status(404).json({ error: 'Skill not installed' });
+    res.json({ id: req.params.id, content });
+  });
+
   // --- Directory Browser ---
 
   app.get('/api/browse', (req, res) => {
@@ -392,19 +433,33 @@ export function createApi(app, daemon) {
         .sort((a, b) => a.name.localeCompare(b.name))
         .map((e) => {
           const childPath = relPath ? `${relPath}/${e.name}` : e.name;
-          // Check if this dir has subdirectories (for expand arrow)
+          const childFull = resolve(fullPath, e.name);
           let hasChildren = false;
+          let childCount = 0;
+          let fileCount = 0;
           try {
-            hasChildren = readdirSync(resolve(fullPath, e.name), { withFileTypes: true })
-              .some((c) => c.isDirectory() && !c.name.startsWith('.') && c.name !== 'node_modules');
+            const children = readdirSync(childFull, { withFileTypes: true });
+            for (const c of children) {
+              if (c.name.startsWith('.') || c.name === 'node_modules') continue;
+              if (c.isDirectory()) { childCount++; hasChildren = true; }
+              else fileCount++;
+            }
           } catch { /* unreadable */ }
-          return { name: e.name, path: childPath, hasChildren };
+          return { name: e.name, path: childPath, hasChildren, childCount, fileCount };
         });
 
+      // Count files in current dir
+      let currentFiles = 0;
+      try {
+        currentFiles = readdirSync(fullPath, { withFileTypes: true })
+          .filter((e) => e.isFile() && !e.name.startsWith('.')).length;
+      } catch { /* ignore */ }
+
       res.json({
         current: relPath || '.',
         parent: relPath ? relPath.split('/').slice(0, -1).join('/') : null,
         dirs: entries,
+        fileCount: currentFiles,
       });
     } catch (err) {
       res.status(500).json({ error: err.message });

package/node_modules/@groove-dev/daemon/src/index.js

@@ -27,6 +27,7 @@ import { ProjectManager } from './pm.js';
 import { CodebaseIndexer } from './indexer.js';
 import { AuditLogger } from './audit.js';
 import { Federation } from './federation.js';
+import { SkillStore } from './skills.js';
 import { isFirstRun, runFirstTimeSetup, loadConfig, saveConfig, printWelcome } from './firstrun.js';
 
 const DEFAULT_PORT = 31415;
@@ -115,6 +116,7 @@ export class Daemon {
     this.indexer = new CodebaseIndexer(this);
     this.audit = new AuditLogger(this.grooveDir);
     this.federation = new Federation(this);
+    this.skills = new SkillStore(this);
 
     // HTTP + WebSocket server
     this.app = express();

package/node_modules/@groove-dev/daemon/src/skills.js

@@ -0,0 +1,198 @@
+// GROOVE — Skill Store
+// FSL-1.1-Apache-2.0 — see LICENSE
+
+import { existsSync, mkdirSync, writeFileSync, readFileSync, readdirSync, unlinkSync, rmSync } from 'fs';
+import { resolve, dirname } from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+export class SkillStore {
+  constructor(daemon) {
+    this.daemon = daemon;
+    this.skillsDir = resolve(daemon.grooveDir, 'skills');
+    mkdirSync(this.skillsDir, { recursive: true });
+
+    // Load bundled registry
+    this.registry = [];
+    try {
+      const regPath = resolve(__dirname, '../skills-registry.json');
+      this.registry = JSON.parse(readFileSync(regPath, 'utf8'));
+    } catch { /* no registry file */ }
+  }
+
+  /**
+   * Get all skills from the registry with installed status.
+   */
+  getRegistry(query) {
+    let skills = this.registry.map((s) => ({
+      ...s,
+      installed: this._isInstalled(s.id),
+    }));
+
+    // Search filter
+    if (query?.search) {
+      const q = query.search.toLowerCase();
+      skills = skills.filter((s) =>
+        s.name.toLowerCase().includes(q)
+        || s.description.toLowerCase().includes(q)
+        || s.tags.some((t) => t.includes(q))
+      );
+    }
+
+    // Category filter
+    if (query?.category && query.category !== 'all') {
+      skills = skills.filter((s) => s.category === query.category);
+    }
+
+    return skills;
+  }
+
+  /**
+   * Get installed skills only.
+   */
+  getInstalled() {
+    const installed = [];
+    if (!existsSync(this.skillsDir)) return installed;
+
+    for (const dir of readdirSync(this.skillsDir, { withFileTypes: true })) {
+      if (!dir.isDirectory()) continue;
+      const skillPath = resolve(this.skillsDir, dir.name, 'SKILL.md');
+      if (!existsSync(skillPath)) continue;
+
+      const content = readFileSync(skillPath, 'utf8');
+      const meta = this._parseFrontmatter(content);
+
+      // Merge with registry info if available
+      const regEntry = this.registry.find((r) => r.id === dir.name);
+
+      installed.push({
+        id: dir.name,
+        name: meta.name || regEntry?.name || dir.name,
+        description: meta.description || regEntry?.description || '',
+        category: regEntry?.category || 'custom',
+        tags: regEntry?.tags || [],
+        roles: regEntry?.roles || [],
+        author: regEntry?.author || 'local',
+        installed: true,
+      });
+    }
+
+    return installed;
+  }
+
+  /**
+   * Install a skill from the registry.
+   * Copies the SKILL.md content from the Claude plugins directory.
+   */
+  install(skillId) {
+    const entry = this.registry.find((s) => s.id === skillId);
+    if (!entry) throw new Error(`Skill not found: ${skillId}`);
+    if (this._isInstalled(skillId)) throw new Error(`Skill already installed: ${skillId}`);
+
+    // Find the skill content from Claude's plugin directory
+    const content = this._findSkillContent(skillId);
+    if (!content) {
+      throw new Error(`Skill content not found. Make sure Claude Code plugins are installed.`);
+    }
+
+    // Save to .groove/skills/<id>/SKILL.md
+    const skillDir = resolve(this.skillsDir, skillId);
+    mkdirSync(skillDir, { recursive: true });
+    writeFileSync(resolve(skillDir, 'SKILL.md'), content);
+
+    this.daemon.audit.log('skill.install', { id: skillId, name: entry.name });
+
+    return { id: skillId, name: entry.name, installed: true };
+  }
+
+  /**
+   * Uninstall a skill.
+   */
+  uninstall(skillId) {
+    const skillDir = resolve(this.skillsDir, skillId);
+    if (!existsSync(skillDir)) throw new Error(`Skill not installed: ${skillId}`);
+
+    rmSync(skillDir, { recursive: true });
+    this.daemon.audit.log('skill.uninstall', { id: skillId });
+
+    return { id: skillId, installed: false };
+  }
+
+  /**
+   * Get the full content of an installed skill.
+   */
+  getContent(skillId) {
+    const skillPath = resolve(this.skillsDir, skillId, 'SKILL.md');
+    if (!existsSync(skillPath)) return null;
+    return readFileSync(skillPath, 'utf8');
+  }
+
+  /**
+   * Get available categories from the registry.
+   */
+  getCategories() {
+    const cats = new Map();
+    for (const skill of this.registry) {
+      const count = cats.get(skill.category) || 0;
+      cats.set(skill.category, count + 1);
+    }
+    return Array.from(cats.entries())
+      .map(([id, count]) => ({ id, count }))
+      .sort((a, b) => b.count - a.count);
+  }
+
+  // --- Internal ---
+
+  _isInstalled(skillId) {
+    return existsSync(resolve(this.skillsDir, skillId, 'SKILL.md'));
+  }
+
+  _findSkillContent(skillId) {
+    // Search Claude's plugins directory for the skill
+    const pluginsBase = resolve(process.env.HOME || '~', '.claude', 'plugins', 'marketplaces', 'claude-plugins-official', 'plugins');
+
+    if (!existsSync(pluginsBase)) return null;
+
+    // Skills can be nested: plugins/<plugin>/skills/<skill>/SKILL.md
+    for (const pluginDir of readdirSync(pluginsBase)) {
+      const skillsPath = resolve(pluginsBase, pluginDir, 'skills');
+      if (!existsSync(skillsPath)) continue;
+
+      for (const skillDir of readdirSync(skillsPath)) {
+        if (skillDir === skillId || pluginDir === skillId) {
+          const skillFile = resolve(skillsPath, skillDir, 'SKILL.md');
+          if (existsSync(skillFile)) {
+            return readFileSync(skillFile, 'utf8');
+          }
+        }
+      }
+
+      // Also check commands/<id>.md
+      const cmdsPath = resolve(pluginsBase, pluginDir, 'commands');
+      if (!existsSync(cmdsPath)) continue;
+
+      const cmdFile = resolve(cmdsPath, `${skillId}.md`);
+      if (existsSync(cmdFile)) {
+        return readFileSync(cmdFile, 'utf8');
+      }
+    }
+
+    return null;
+  }
+
+  _parseFrontmatter(content) {
+    const match = content.match(/^---\n([\s\S]*?)\n---/);
+    if (!match) return {};
+
+    const meta = {};
+    for (const line of match[1].split('\n')) {
+      const sep = line.indexOf(':');
+      if (sep === -1) continue;
+      const key = line.slice(0, sep).trim();
+      const val = line.slice(sep + 1).trim();
+      meta[key] = val;
+    }
+    return meta;
+  }
+}