@codihaus/claude-skills 1.0.0

package/src/utils/skills.js

@@ -0,0 +1,253 @@
+/**
+ * Skills Management Utilities
+ *
+ * Copy, list, and manage skills in projects.
+ */
+
+import fs from 'fs-extra';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// Path to bundled skills (in npm package)
+const SKILLS_SOURCE = path.join(__dirname, '../../skills');
+
+/**
+ * Get list of all available skills
+ */
+export async function getAvailableSkills() {
+  const skills = [];
+
+  // Read main skills
+  const mainSkills = await fs.readdir(SKILLS_SOURCE);
+
+  for (const name of mainSkills) {
+    const skillPath = path.join(SKILLS_SOURCE, name);
+    const stat = await fs.stat(skillPath);
+
+    if (!stat.isDirectory()) continue;
+
+    // Check if it's a skill (has SKILL.md) or a category folder (like utils/)
+    const skillMd = path.join(skillPath, 'SKILL.md');
+
+    if (await fs.pathExists(skillMd)) {
+      // It's a skill
+      const metadata = await parseSkillMetadata(skillMd);
+      skills.push({
+        name,
+        path: skillPath,
+        ...metadata
+      });
+    } else {
+      // It's a category folder (like utils/), check subdirectories
+      const subItems = await fs.readdir(skillPath);
+
+      for (const subName of subItems) {
+        const subPath = path.join(skillPath, subName);
+        const subStat = await fs.stat(subPath);
+
+        if (!subStat.isDirectory()) continue;
+
+        const subSkillMd = path.join(subPath, 'SKILL.md');
+        if (await fs.pathExists(subSkillMd)) {
+          const metadata = await parseSkillMetadata(subSkillMd);
+          skills.push({
+            name: `${name}/${subName}`,
+            path: subPath,
+            category: name,
+            ...metadata
+          });
+        }
+      }
+    }
+  }
+
+  // Also include special files
+  const specialFiles = ['_registry.md', '_quality-attributes.md'];
+  for (const file of specialFiles) {
+    const filePath = path.join(SKILLS_SOURCE, file);
+    if (await fs.pathExists(filePath)) {
+      skills.push({
+        name: file,
+        path: filePath,
+        type: 'config'
+      });
+    }
+  }
+
+  return skills;
+}
+
+/**
+ * Parse skill metadata from SKILL.md frontmatter
+ */
+async function parseSkillMetadata(skillMdPath) {
+  try {
+    const content = await fs.readFile(skillMdPath, 'utf-8');
+    const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---/);
+
+    if (!frontmatterMatch) {
+      return { version: 'unknown', description: '' };
+    }
+
+    const frontmatter = frontmatterMatch[1];
+    const metadata = {};
+
+    // Parse YAML-like frontmatter
+    const lines = frontmatter.split('\n');
+    for (const line of lines) {
+      const match = line.match(/^(\w+):\s*(.+)$/);
+      if (match) {
+        metadata[match[1]] = match[2].trim();
+      }
+    }
+
+    return metadata;
+  } catch (e) {
+    return { version: 'unknown', description: '' };
+  }
+}
+
+/**
+ * Get installed skills in a project
+ */
+export async function getInstalledSkills(projectPath) {
+  const skillsPath = path.join(projectPath, '.claude', 'skills');
+
+  if (!await fs.pathExists(skillsPath)) {
+    return [];
+  }
+
+  const skills = [];
+  const items = await fs.readdir(skillsPath);
+
+  for (const name of items) {
+    const itemPath = path.join(skillsPath, name);
+    const stat = await fs.stat(itemPath);
+
+    if (!stat.isDirectory()) {
+      // Config files like _registry.md
+      if (name.endsWith('.md')) {
+        skills.push({ name, type: 'config' });
+      }
+      continue;
+    }
+
+    const skillMd = path.join(itemPath, 'SKILL.md');
+    if (await fs.pathExists(skillMd)) {
+      const metadata = await parseSkillMetadata(skillMd);
+      skills.push({
+        name,
+        path: itemPath,
+        ...metadata
+      });
+    } else {
+      // Check for nested skills (like utils/)
+      const subItems = await fs.readdir(itemPath);
+      for (const subName of subItems) {
+        const subPath = path.join(itemPath, subName);
+        const subStat = await fs.stat(subPath);
+
+        if (!subStat.isDirectory()) continue;
+
+        const subSkillMd = path.join(subPath, 'SKILL.md');
+        if (await fs.pathExists(subSkillMd)) {
+          const metadata = await parseSkillMetadata(subSkillMd);
+          skills.push({
+            name: `${name}/${subName}`,
+            path: subPath,
+            category: name,
+            ...metadata
+          });
+        }
+      }
+    }
+  }
+
+  return skills;
+}
+
+/**
+ * Copy skills to project
+ */
+export async function copySkillsToProject(projectPath, skillNames = null) {
+  const targetPath = path.join(projectPath, '.claude', 'skills');
+
+  // Ensure target directory exists
+  await fs.ensureDir(targetPath);
+
+  const available = await getAvailableSkills();
+  const toCopy = skillNames
+    ? available.filter(s => skillNames.includes(s.name) || s.type === 'config')
+    : available;
+
+  const copied = [];
+  const errors = [];
+
+  for (const skill of toCopy) {
+    try {
+      const targetSkillPath = path.join(targetPath, skill.name);
+
+      if (skill.type === 'config') {
+        // Copy single file
+        await fs.copy(skill.path, path.join(targetPath, skill.name));
+      } else {
+        // Copy directory
+        await fs.copy(skill.path, targetSkillPath);
+      }
+
+      copied.push(skill.name);
+    } catch (e) {
+      errors.push({ name: skill.name, error: e.message });
+    }
+  }
+
+  return { copied, errors };
+}
+
+/**
+ * Remove a skill from project
+ */
+export async function removeSkillFromProject(projectPath, skillName) {
+  const targetPath = path.join(projectPath, '.claude', 'skills', skillName);
+
+  if (!await fs.pathExists(targetPath)) {
+    return { success: false, error: 'Skill not found' };
+  }
+
+  try {
+    await fs.remove(targetPath);
+    return { success: true };
+  } catch (e) {
+    return { success: false, error: e.message };
+  }
+}
+
+/**
+ * Check if skills need updating
+ */
+export async function checkForUpdates(projectPath) {
+  const installed = await getInstalledSkills(projectPath);
+  const available = await getAvailableSkills();
+
+  const updates = [];
+
+  for (const installedSkill of installed) {
+    if (installedSkill.type === 'config') continue;
+
+    const availableSkill = available.find(a => a.name === installedSkill.name);
+    if (!availableSkill) continue;
+
+    if (installedSkill.version !== availableSkill.version) {
+      updates.push({
+        name: installedSkill.name,
+        current: installedSkill.version,
+        available: availableSkill.version
+      });
+    }
+  }
+
+  return updates;
+}

package/templates/CLAUDE.md.template

@@ -0,0 +1,58 @@
+# CLAUDE.md
+
+Project-specific instructions for Claude Code.
+
+## Skills
+
+This project uses CodiHaus Claude Skills. Available skills:
+
+| Skill | Purpose |
+|-------|---------|
+| `/debrief` | Create BRD and use cases from requirements |
+| `/dev-scout` | Explore and document existing codebase |
+| `/dev-arch` | Make architecture decisions |
+| `/dev-specs` | Create implementation specifications |
+| `/dev-coding` | Implement features from specs |
+| `/dev-test` | Automated UI testing |
+| `/dev-review` | Code review with quality checks |
+| `/dev-changelog` | Document what was implemented |
+
+### Utility Skills (called by other skills)
+
+| Skill | Purpose |
+|-------|---------|
+| `/utils/diagram` | Mermaid diagram validation |
+| `/utils/docs-graph` | Documentation relationship viewer |
+| `/utils/gemini` | Large codebase scanning |
+
+See `.claude/skills/_registry.md` for full documentation.
+
+## Project Overview
+
+{Add your project description here}
+
+## Tech Stack
+
+{List your technologies here}
+
+## Development
+
+### Getting Started
+
+```bash
+# Install dependencies
+npm install
+
+# Start development server
+npm run dev
+```
+
+### Testing
+
+```bash
+npm test
+```
+
+## Conventions
+
+{Add any project-specific conventions here}