joyskills-cli 0.1.1

package/src/index.js

@@ -0,0 +1,27 @@
+#!/usr/bin/env node
+
+import { Command } from 'commander';
+import { listCommand } from './commands/list.js';
+import { installCommand } from './commands/install.js';
+import { removeCommand } from './commands/remove.js';
+import { teamCommand } from './commands/team.js';
+import { auditCommand } from './commands/audit.js';
+import { statusCommand } from './commands/status.js';
+
+const program = new Command();
+
+program
+  .name('joySkills')
+  .description('Team-level skill governance compatible with open skill / Claude Skills')
+  .version('0.1.0');
+
+// Add commands
+listCommand(program);
+installCommand(program);
+removeCommand(program);
+teamCommand(program);
+auditCommand(program);
+statusCommand(program);
+
+// Parse arguments
+program.parse();

package/src/local.js

@@ -0,0 +1,93 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { LocalSkill } from './types.js';
+
+export class LocalManager {
+  constructor(projectRoot) {
+    this.projectRoot = projectRoot;
+  }
+
+  /**
+   * Get local skills directory path
+   */
+  getSkillsDir() {
+    return path.join(this.projectRoot, 'skills');
+  }
+
+  /**
+   * List all local skills
+   */
+  listSkills() {
+    const skillsDir = this.getSkillsDir();
+    if (!fs.existsSync(skillsDir)) {
+      return [];
+    }
+
+    return fs.readdirSync(skillsDir, { withFileTypes: true })
+      .filter(dirent => dirent.isDirectory())
+      .map(dirent => dirent.name);
+  }
+
+  /**
+   * Check if a skill exists locally
+   */
+  hasSkill(skillName) {
+    const skillPath = path.join(this.getSkillsDir(), skillName);
+    return fs.existsSync(skillPath);
+  }
+
+  /**
+   * Read SKILL.md content of a local skill
+   */
+  readSkill(skillName) {
+    const skillPath = path.join(this.getSkillsDir(), skillName);
+    if (!this.hasSkill(skillName)) {
+      return null;
+    }
+
+    const skillMdPath = path.join(skillPath, 'SKILL.md');
+    if (!fs.existsSync(skillMdPath)) {
+      return null;
+    }
+
+    const content = fs.readFileSync(skillMdPath, 'utf-8');
+    return new LocalSkill(skillName, skillPath, content);
+  }
+
+  /**
+   * Install a skill (create directory and SKILL.md)
+   */
+  installSkill(skillName, skillMdContent) {
+    const skillsDir = this.getSkillsDir();
+
+    // Create skills directory if not exists
+    if (!fs.existsSync(skillsDir)) {
+      fs.mkdirSync(skillsDir, { recursive: true });
+    }
+
+    const skillPath = path.join(skillsDir, skillName);
+
+    // Create skill directory
+    if (!fs.existsSync(skillPath)) {
+      fs.mkdirSync(skillPath, { recursive: true });
+    }
+
+    // Write SKILL.md
+    const skillMdPath = path.join(skillPath, 'SKILL.md');
+    fs.writeFileSync(skillMdPath, skillMdContent);
+  }
+
+  /**
+   * Remove a local skill
+   */
+  removeSkill(skillName) {
+    const skillPath = path.join(this.getSkillsDir(), skillName);
+    if (!fs.existsSync(skillPath)) {
+      return false;
+    }
+
+    // Remove skill directory recursively
+    fs.rmSync(skillPath, { recursive: true, force: true });
+    return true;
+  }
+}

package/src/lockfile.js

@@ -0,0 +1,76 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as yaml from 'yaml';
+
+export class LockfileManager {
+  constructor(projectRoot) {
+    this.lockfilePath = path.join(projectRoot, 'joySkills.lock');
+    this.lockData = {
+      lockVersion: 1,
+      skills: {}
+    };
+  }
+
+  /**
+   * Load existing lockfile or initialize new one
+   */
+  async load() {
+    if (!fs.existsSync(this.lockfilePath)) {
+      // Initialize empty if not exists
+      return;
+    }
+
+    const content = await fs.promises.readFile(this.lockfilePath, 'utf-8');
+    try {
+      this.lockData = yaml.parse(content);
+    } catch (e) {
+      throw new Error(`Failed to parse joyskill.lock: ${e.message}`);
+    }
+  }
+
+  /**
+   * Save lockfile to disk
+   */
+  async save() {
+    const content = yaml.stringify(this.lockData);
+    await fs.promises.writeFile(this.lockfilePath, content, 'utf-8');
+  }
+
+  /**
+   * Update or add a skill entry
+   */
+  updateSkill(skillId, entry) {
+    this.lockData.skills[skillId] = entry;
+  }
+
+  /**
+   * Remove a skill entry
+   */
+  removeSkill(skillId) {
+    delete this.lockData.skills[skillId];
+  }
+
+  /**
+   * Get skill entry
+   */
+  getSkill(skillId) {
+    return this.lockData.skills[skillId];
+  }
+
+  /**
+   * Bind a registry
+   */
+  bindRegistry(registryId, alias) {
+    if (!this.lockData.registryBindings) {
+      this.lockData.registryBindings = [];
+    }
+
+    // Check if already bound
+    const existing = this.lockData.registryBindings.find(b => b.registryId === registryId);
+    if (existing) {
+      existing.alias = alias;
+    } else {
+      this.lockData.registryBindings.push({ registryId, alias });
+    }
+  }
+}

package/src/registry.js

@@ -0,0 +1,273 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as yaml from 'yaml';
+
+export class RegistryManager {
+  constructor(registryPath) {
+    this.index = null;
+    this.registryPath = registryPath;
+  }
+
+  /**
+   * Load and parse registry.yaml
+   */
+  async load() {
+    const indexPath = path.join(this.registryPath, 'registry.yaml');
+    if (!fs.existsSync(indexPath)) {
+      throw new Error(`Registry index not found at ${indexPath}`);
+    }
+
+    const content = await fs.promises.readFile(indexPath, 'utf-8');
+    try {
+      this.index = yaml.parse(content);
+    } catch (e) {
+      throw new Error(`Failed to parse registry.yaml: ${e.message}`);
+    }
+  }
+
+  /**
+   * Get all skills in the registry
+   */
+  getAllSkills() {
+    if (!this.index) throw new Error('Registry not loaded');
+    return this.index.skills || [];
+  }
+
+  /**
+   * Get metadata for a specific skill
+   */
+  getSkill(skillId) {
+    if (!this.index) throw new Error('Registry not loaded');
+    return this.index.skills.find(s => s.id === skillId);
+  }
+
+  /**
+   * Get the recommended version for a skill
+   */
+  getRecommendedVersion(skillId) {
+    const skill = this.getSkill(skillId);
+    if (!skill) return undefined;
+
+    // First look for explicitly recommended version
+    const recommended = skill.versions.find(v => v.recommended && v.state === 'approved');
+    if (recommended) return recommended;
+
+    // Fallback: find latest approved version
+    // Assuming versions are semver, sorting might be needed.
+    // For simplicity now, just taking the first approved one,
+    // but in production this should use semver-sort.
+    return skill.versions.find(v => v.state === 'approved');
+  }
+
+  /**
+   * Get the latest version for a skill
+   */
+  getLatestVersion(skillId) {
+    const skill = this.getSkill(skillId);
+    if (!skill) return undefined;
+
+    // Find the latest approved version
+    // For now, just return the first approved version
+    // In production, this should properly sort by version
+    return skill.versions.find(v => v.state === 'approved');
+  }
+
+  /**
+   * Check if a version exists and is approved
+   */
+  getVersion(skillId, version) {
+    const skill = this.getSkill(skillId);
+    if (!skill) return undefined;
+    return skill.versions.find(v => v.version === version);
+  }
+
+  /**
+   * Search skills by name or description
+   */
+  searchSkills(query) {
+    if (!this.index) throw new Error('Registry not loaded');
+
+    const lowercaseQuery = query.toLowerCase();
+    return this.index.skills.filter(skill =>
+      skill.id.toLowerCase().includes(lowercaseQuery) ||
+      (skill.name && skill.name.toLowerCase().includes(lowercaseQuery)) ||
+      (skill.description && skill.description.toLowerCase().includes(lowercaseQuery))
+    );
+  }
+
+  /**
+   * Get skills by category
+   */
+  getSkillsByCategory(category) {
+    if (!this.index) throw new Error('Registry not loaded');
+    return this.index.skills.filter(skill => skill.category === category);
+  }
+
+  /**
+   * Get all categories
+   */
+  getCategories() {
+    if (!this.index) throw new Error('Registry not loaded');
+    const categories = new Set();
+    this.index.skills.forEach(skill => {
+      if (skill.category) {
+        categories.add(skill.category);
+      }
+    });
+    return Array.from(categories);
+  }
+
+  /**
+   * Check if a skill exists in the registry
+   */
+  hasSkill(skillId) {
+    return this.getSkill(skillId) !== undefined;
+  }
+
+  /**
+   * Validate a skill version
+   */
+  validateVersion(skillId, version) {
+    const skill = this.getSkill(skillId);
+    if (!skill) {
+      return { valid: false, error: 'Skill not found in registry' };
+    }
+
+    const versionData = this.getVersion(skillId, version);
+    if (!versionData) {
+      return { valid: false, error: 'Version not found' };
+    }
+
+    if (versionData.state === 'draft') {
+      return { valid: false, error: 'Version is in draft state' };
+    }
+
+    if (versionData.state === 'pending_review') {
+      return { valid: false, error: 'Version is pending review' };
+    }
+
+    if (versionData.state === 'deprecated') {
+      return { valid: true, warning: 'Version is deprecated' };
+    }
+
+    return { valid: true };
+  }
+
+  /**
+   * Get all approved skills
+   */
+  getApprovedSkills() {
+    if (!this.index) throw new Error('Registry not loaded');
+    return this.index.skills.filter(skill =>
+      skill.versions.some(version => version.state === 'approved')
+    );
+  }
+
+  /**
+   * Get skills by visibility
+   */
+  getSkillsByVisibility(visibility) {
+    if (!this.index) throw new Error('Registry not loaded');
+    return this.index.skills.filter(skill => skill.visibility === visibility);
+  }
+
+  /**
+   * Get registry info
+   */
+  getRegistryInfo() {
+    if (!this.index) throw new Error('Registry not loaded');
+    return {
+      registryVersion: this.index.registryVersion,
+      registryId: this.index.registryId
+    };
+  }
+
+  /**
+   * Get skills by author
+   */
+  getSkillsByAuthor(author) {
+    if (!this.index) throw new Error('Registry not loaded');
+    return this.index.skills.filter(skill => skill.author === author);
+  }
+
+  /**
+   * Get skills by tags
+   */
+  getSkillsByTags(tags) {
+    if (!this.index) throw new Error('Registry not loaded');
+    const tagArray = Array.isArray(tags) ? tags : [tags];
+    return this.index.skills.filter(skill =>
+      skill.tags && tagArray.some(tag => skill.tags.includes(tag))
+    );
+  }
+
+  /**
+   * Get skill download URL
+   */
+  getSkillDownloadUrl(skillId, version) {
+    const skill = this.getSkill(skillId);
+    if (!skill) return null;
+
+    const versionData = this.getVersion(skillId, version);
+    if (!versionData) return null;
+
+    return versionData.downloadUrl || null;
+  }
+
+  /**
+   * Get skill checksum
+   */
+  getSkillChecksum(skillId, version) {
+    const skill = this.getSkill(skillId);
+    if (!skill) return null;
+
+    const versionData = this.getVersion(skillId, version);
+    if (!versionData) return null;
+
+    return versionData.checksum || null;
+  }
+
+  /**
+   * Get all versions for a skill
+   */
+  getAllVersions(skillId) {
+    const skill = this.getSkill(skillId);
+    if (!skill) return [];
+    return skill.versions || [];
+  }
+
+  /**
+   * Get approved versions for a skill
+   */
+  getApprovedVersions(skillId) {
+    const skill = this.getSkill(skillId);
+    if (!skill) return [];
+    return (skill.versions || []).filter(v => v.state === 'approved');
+  }
+
+  /**
+   * Get skill dependencies
+   */
+  getSkillDependencies(skillId, version) {
+    const skill = this.getSkill(skillId);
+    if (!skill) return [];
+
+    const versionData = this.getVersion(skillId, version);
+    if (!versionData) return [];
+
+    return versionData.dependencies || [];
+  }
+
+  /**
+   * Check if skill is deprecated
+   */
+  isSkillDeprecated(skillId, version) {
+    const skill = this.getSkill(skillId);
+    if (!skill) return false;
+
+    const versionData = this.getVersion(skillId, version);
+    if (!versionData) return false;
+
+    return versionData.state === 'deprecated';
+  }
+}

package/src/types.js

@@ -0,0 +1,34 @@
+/**
+ * JoySkill Core Type Definitions
+ * Based on spec/registry-spec.md and spec/lockfile-spec.md
+ */
+
+// === Registry Types ===
+
+export const SkillVisibility = {
+  PUBLIC: 'public',
+  RESTRICTED: 'restricted',
+  INTERNAL: 'internal'
+};
+
+export const SkillVersionState = {
+  DRAFT: 'draft',
+  PENDING_REVIEW: 'pending_review',
+  APPROVED: 'approved',
+  DEPRECATED: 'deprecated',
+  ARCHIVED: 'archived'
+};
+
+// === Lockfile Types ===
+
+export const LockfileVersion = 1;
+
+// === Local Skill Types ===
+
+export class LocalSkill {
+  constructor(name, path, skillMdContent) {
+    this.name = name;
+    this.path = path;
+    this.skillMdContent = skillMdContent;
+  }
+}