joyskills-cli 0.2.5 → 0.2.7

package/src/commands/team.js

@@ -1,92 +1,312 @@
 import { Command } from 'commander';
 import { LockfileManager } from '../lockfile.js';
+import { RegistryManager } from '../registry.js';
+import simpleGit from 'simple-git';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import { input, confirm } from '@inquirer/prompts';
+import chalk from 'chalk';
+
+const JOYSKILL_DIR = process.env.JOYSKILL_CONFIG_DIR || path.join(os.homedir(), '.joyskill');
+const REGISTRY_CACHE_DIR = path.join(JOYSKILL_DIR, 'registries');
 
 export function teamCommand(program) {
   const teamProgram = program
     .command('team')
     .description('Team registry management');
 
+  // team add - Add a team registry
   teamProgram
-    .command('add <name> <path>')
-    .description('Add a team registry')
-    .action(async (name, path) => {
-      const projectRoot = process.cwd();
-      const lockfileManager = new LockfileManager(projectRoot);
+    .command('add <name> <git-url>')
+    .description('Add a team registry from Git URL')
+    .action(async (name, gitUrl) => {
+      try {
+        console.log(chalk.blue(`📦 Adding team registry: ${name}`));
+        console.log(chalk.gray(`   URL: ${gitUrl}`));
+        
+        // Clone registry to cache
+        const registryCachePath = path.join(REGISTRY_CACHE_DIR, name);
+        
+        if (fs.existsSync(registryCachePath)) {
+          const overwrite = await confirm({
+            message: `Registry "${name}" already exists. Overwrite?`,
+            default: false
+          });
+          if (!overwrite) {
+            console.log(chalk.gray('   Cancelled'));
+            return;
+          }
+          fs.rmSync(registryCachePath, { recursive: true, force: true });
+        }
+        
+        fs.mkdirSync(registryCachePath, { recursive: true });
+        
+        // Clone the registry
+        const git = simpleGit();
+        await git.clone(gitUrl, registryCachePath, ['--depth', '1']);
+        
+        // Validate registry structure (flexible: registry.yaml is optional)
+        const registryYamlPath = path.join(registryCachePath, 'registry.yaml');
+        const hasRegistryYaml = fs.existsSync(registryYamlPath);
 
-      console.log(`Adding team registry: ${name} -> ${path}`);
+        // Count skill directories (dirs with SKILL.md)
+        const entries = fs.readdirSync(registryCachePath, { withFileTypes: true });
+        const skillDirs = entries.filter(e => e.isDirectory() && fs.existsSync(path.join(registryCachePath, e.name, 'SKILL.md')));
 
-      try {
-        await lockfileManager.load();
-        lockfileManager.bindRegistry(path, name);
-        await lockfileManager.save();
-        console.log(`✅ Successfully added registry ${name}`);
+        if (!hasRegistryYaml && skillDirs.length === 0) {
+          throw new Error('Invalid registry: no registry.yaml and no skill directories found');
+        }
+
+        // Save to global config
+        const configPath = path.join(JOYSKILL_DIR, 'config.json');
+        let config = { registries: {} };
+        if (fs.existsSync(configPath)) {
+          config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+        }
+
+        let registryId = name;
+        let skillCount = skillDirs.length;
+
+        if (hasRegistryYaml) {
+          const registryManager = new RegistryManager(registryCachePath);
+          await registryManager.load();
+          const info = registryManager.getRegistryInfo();
+          registryId = info.registryId;
+          skillCount = registryManager.getAllSkills().length;
+        }
+
+        config.registries[name] = {
+          url: gitUrl,
+          path: registryCachePath,
+          registryId,
+          addedAt: new Date().toISOString()
+        };
+
+        fs.mkdirSync(JOYSKILL_DIR, { recursive: true });
+        fs.writeFileSync(configPath, JSON.stringify(config, null, 2), 'utf-8');
+
+        console.log(chalk.green(`✅ Successfully added registry: ${name}`));
+        console.log(chalk.gray(`   Registry ID: ${registryId}`));
+        console.log(chalk.gray(`   Skills: ${skillCount}${hasRegistryYaml ? '' : ' (no registry.yaml, direct scan)'}`));
+        
       } catch (error) {
-        console.error(`❌ Failed to add registry:`, error);
+        console.error(chalk.red(`❌ Failed to add registry: ${error.message}`));
+        process.exit(1);
       }
     });
 
+  // team remove - Remove a team registry
   teamProgram
     .command('remove <name>')
     .description('Remove a team registry')
     .action(async (name) => {
-      const projectRoot = process.cwd();
-      const lockfileManager = new LockfileManager(projectRoot);
-
-      console.log(`Removing team registry: ${name}`);
-
       try {
-        await lockfileManager.load();
-        lockfileManager.unbindRegistry(name);
-        await lockfileManager.save();
-        console.log(`✅ Successfully removed registry ${name}`);
+        const configPath = path.join(JOYSKILL_DIR, 'config.json');
+        if (!fs.existsSync(configPath)) {
+          console.log(chalk.yellow('⚠️  No registries configured'));
+          return;
+        }
+        
+        const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+        
+        if (!config.registries[name]) {
+          console.log(chalk.yellow(`⚠️  Registry "${name}" not found`));
+          return;
+        }
+        
+        // Remove cache
+        const registryPath = config.registries[name].path;
+        if (fs.existsSync(registryPath)) {
+          fs.rmSync(registryPath, { recursive: true, force: true });
+        }
+        
+        // Remove from config
+        delete config.registries[name];
+        fs.writeFileSync(configPath, JSON.stringify(config, null, 2), 'utf-8');
+        
+        console.log(chalk.green(`✅ Successfully removed registry: ${name}`));
+        
       } catch (error) {
-        console.error(`❌ Failed to remove registry:`, error);
+        console.error(chalk.red(`❌ Failed to remove registry: ${error.message}`));
+        process.exit(1);
       }
     });
 
+  // team list - List team registries
   teamProgram
     .command('list')
     .description('List team registries')
     .action(async () => {
-      const projectRoot = process.cwd();
-      const lockfileManager = new LockfileManager(projectRoot);
-
-      console.log('Team Registries:');
-      console.log('================');
-
       try {
-        await lockfileManager.load();
-
-        const registries = lockfileManager.lockData.registries || {};
-        const registryNames = Object.keys(registries);
-
-        if (registryNames.length === 0) {
-          console.log('No team registries configured.');
+        const configPath = path.join(JOYSKILL_DIR, 'config.json');
+        
+        if (!fs.existsSync(configPath)) {
+          console.log(chalk.yellow('⚠️  No registries configured'));
+          console.log(chalk.gray('   Run: joySkills team add <name> <git-url>'));
           return;
         }
-
-        for (const name of registryNames) {
-          const registry = registries[name];
-          console.log(`${name}: ${registry.path}`);
+        
+        const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+        const registries = config.registries || {};
+        const names = Object.keys(registries);
+        
+        if (names.length === 0) {
+          console.log(chalk.yellow('⚠️  No registries configured'));
+          return;
+        }
+        
+        console.log(chalk.blue('\n📦 Team Registries:'));
+        console.log(chalk.gray('─'.repeat(60)));
+        
+        for (const name of names) {
+          const reg = registries[name];
+          const exists = fs.existsSync(reg.path);
+          const status = exists ? chalk.green('✓') : chalk.red('✗');
+          
+          console.log(`   ${status} ${chalk.bold(name)}`);
+          console.log(`     URL: ${chalk.gray(reg.url)}`);
+          console.log(`     ID: ${chalk.gray(reg.registryId)}`);
+          
+          if (exists) {
+            try {
+              // Only load RegistryManager if registry.yaml exists
+              const hasYaml = fs.existsSync(path.join(reg.path, 'registry.yaml'));
+              if (hasYaml) {
+                const registryManager = new RegistryManager(reg.path);
+                await registryManager.load();
+                console.log(`     Skills: ${chalk.blue(registryManager.getAllSkills().length)}`);
+              } else {
+                // Count skill dirs directly
+                const dirs = fs.readdirSync(reg.path, { withFileTypes: true })
+                  .filter(e => e.isDirectory() && fs.existsSync(path.join(reg.path, e.name, 'SKILL.md')));
+                console.log(`     Skills: ${chalk.blue(dirs.length)} ${chalk.gray('(direct)')}`);
+              }
+            } catch (e) {
+              console.log(`     ${chalk.yellow('Warning: Invalid registry')}`);
+            }
+          } else {
+            console.log(`     ${chalk.red('Error: Cache missing')}`);
+          }
+          console.log();
         }
+        
       } catch (error) {
-        console.error(`❌ Failed to list registries:`, error);
+        console.error(chalk.red(`❌ Failed to list registries: ${error.message}`));
+        process.exit(1);
       }
     });
 
+  // team sync - Sync team registry
   teamProgram
     .command('sync [name]')
-    .description('Sync team registry')
+    .description('Sync team registry from Git')
     .action(async (name) => {
-      console.log(`Syncing registry: ${name || 'all'}`);
-      console.log('(Registry sync functionality coming soon)');
+      try {
+        const configPath = path.join(JOYSKILL_DIR, 'config.json');
+        
+        if (!fs.existsSync(configPath)) {
+          console.log(chalk.yellow('⚠️  No registries configured'));
+          return;
+        }
+        
+        const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+        const registries = config.registries || {};
+        
+        const namesToSync = name 
+          ? [name]
+          : Object.keys(registries);
+        
+        if (namesToSync.length === 0) {
+          console.log(chalk.yellow('⚠️  No registries to sync'));
+          return;
+        }
+        
+        console.log(chalk.blue(`🔄 Syncing ${namesToSync.length} registry(s)...`));
+        
+        for (const registryName of namesToSync) {
+          const reg = registries[registryName];
+          
+          if (!reg) {
+            console.log(chalk.yellow(`⚠️  Registry "${registryName}" not found`));
+            continue;
+          }
+          
+          console.log(chalk.gray(`   Syncing ${registryName}...`));
+          
+          try {
+            if (fs.existsSync(reg.path)) {
+              // Pull updates
+              const git = simpleGit(reg.path);
+              await git.pull();
+              console.log(chalk.green(`   ✓ ${registryName} updated`));
+            } else {
+              // Re-clone
+              fs.mkdirSync(reg.path, { recursive: true });
+              const git = simpleGit();
+              await git.clone(reg.url, reg.path, ['--depth', '1']);
+              console.log(chalk.green(`   ✓ ${registryName} re-cloned`));
+            }
+          } catch (error) {
+            console.error(chalk.red(`   ✗ ${registryName} failed: ${error.message}`));
+          }
+        }
+        
+        console.log(chalk.green('\n✅ Sync completed'));
+        
+      } catch (error) {
+        console.error(chalk.red(`❌ Sync failed: ${error.message}`));
+        process.exit(1);
+      }
     });
 
+  // team use - Set default team registry
   teamProgram
     .command('use <name>')
-    .description('Set default team registry')
+    .description('Set default team registry for current project')
     .action(async (name) => {
-      console.log(`Setting default registry to: ${name}`);
-      console.log('(Registry use functionality coming soon)');
+      try {
+        const configPath = path.join(JOYSKILL_DIR, 'config.json');
+        
+        if (!fs.existsSync(configPath)) {
+          console.log(chalk.yellow('⚠️  No registries configured'));
+          return;
+        }
+        
+        const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+        
+        if (!config.registries[name]) {
+          console.log(chalk.yellow(`⚠️  Registry "${name}" not found`));
+          console.log(chalk.gray('   Run: joySkills team add <name> <git-url>'));
+          return;
+        }
+        
+        // Update project lockfile
+        const projectRoot = process.cwd();
+        const lockfileManager = new LockfileManager(projectRoot);
+        await lockfileManager.load();
+        
+        const reg = config.registries[name];
+        lockfileManager.bindRegistry(reg.registryId, name);
+        await lockfileManager.save();
+        
+        // Create symlink to registry
+        const joyskillDir = path.join(projectRoot, '.joyskill');
+        const registryLink = path.join(joyskillDir, 'registry');
+        
+        if (fs.existsSync(registryLink)) {
+          fs.rmSync(registryLink, { recursive: true, force: true });
+        }
+        
+        fs.mkdirSync(joyskillDir, { recursive: true });
+        fs.symlinkSync(reg.path, registryLink, 'dir');
+        
+        console.log(chalk.green(`✅ Now using registry: ${name}`));
+        console.log(chalk.gray(`   Registry ID: ${reg.registryId}`));
+        
+      } catch (error) {
+        console.error(chalk.red(`❌ Failed to set registry: ${error.message}`));
+        process.exit(1);
+      }
     });
-}
+}

package/src/commands/upgrade.js

@@ -0,0 +1,311 @@
+import { Command } from 'commander';
+import { LocalManager } from '../local.js';
+import { LockfileManager } from '../lockfile.js';
+import { RegistryManager } from '../registry.js';
+import simpleGit from 'simple-git';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import { select, confirm, checkbox } from '@inquirer/prompts';
+import chalk from 'chalk';
+
+const CACHE_DIR = process.env.JOYSKILL_CACHE_DIR || path.join(os.homedir(), '.joyskill', 'cache');
+
+export function upgradeCommand(program) {
+  program
+    .command('upgrade [skill]')
+    .description('Upgrade installed skills to latest versions')
+    .option('-a, --all', 'Upgrade all skills')
+    .option('--dry-run', 'Show what would be upgraded without making changes')
+    .option('-g, --global', 'Upgrade global skills')
+    .action(async (skillName, options) => {
+      try {
+        const projectRoot = process.cwd();
+        const isGlobal = options.global;
+        // Scan both standard dirs; upgrade will check all
+        const skillsDirs = isGlobal
+          ? [path.join(os.homedir(), '.claude', 'skills'), path.join(os.homedir(), '.agent', 'skills')]
+          : [path.join(projectRoot, '.claude', 'skills'), path.join(projectRoot, '.agent', 'skills')];
+        // Use first existing dir as primary, but pass all dirs to findUpgradableSkills
+        const skillsDir = skillsDirs.find(d => fs.existsSync(d)) || skillsDirs[0];
+        
+        const lockfileManager = new LockfileManager(projectRoot);
+        await lockfileManager.load();
+        
+        // Load registry if available
+        const registryPath = path.join(projectRoot, '.joyskill', 'registry');
+        let registryManager = null;
+        if (fs.existsSync(registryPath)) {
+          registryManager = new RegistryManager(registryPath);
+          await registryManager.load();
+        }
+        
+        // Find upgradable skills
+        const upgradableSkills = await findUpgradableSkills(
+          lockfileManager, 
+          registryManager, 
+          skillsDir,
+          skillName
+        );
+        
+        if (upgradableSkills.length === 0) {
+          console.log(chalk.green('✅ All skills are up to date'));
+          return;
+        }
+        
+        // Display available upgrades
+        console.log(chalk.blue('\n📦 Available Upgrades:'));
+        console.log(chalk.gray('─'.repeat(60)));
+        
+        for (const skill of upgradableSkills) {
+          const current = chalk.gray(skill.currentVersion);
+          const latest = chalk.green(skill.latestVersion);
+          const indicator = skill.hasBreakingChange ? chalk.red('⚠️ Breaking') : chalk.blue('Patch/Minor');
+          console.log(`   ${skill.name}: ${current} → ${latest} ${indicator}`);
+          if (skill.changelog) {
+            console.log(`     ${chalk.gray(skill.changelog)}`);
+          }
+        }
+        
+        if (options.dryRun) {
+          console.log(chalk.yellow('\n⚠️  Dry run - no changes made'));
+          return;
+        }
+        
+        // Select skills to upgrade
+        let selectedSkills = [];
+        
+        if (options.all) {
+          selectedSkills = upgradableSkills;
+        } else if (skillName) {
+          const skill = upgradableSkills.find(s => s.name === skillName);
+          if (!skill) {
+            console.log(chalk.green(`✅ ${skillName} is already up to date`));
+            return;
+          }
+          selectedSkills = [skill];
+        } else {
+          const choices = upgradableSkills.map(s => ({
+            name: `${s.name} (${s.currentVersion} → ${s.latestVersion})`,
+            value: s,
+            checked: !s.hasBreakingChange
+          }));
+          
+          selectedSkills = await checkbox({
+            message: 'Select skills to upgrade:',
+            choices: choices
+          });
+        }
+        
+        if (selectedSkills.length === 0) {
+          console.log(chalk.gray('   No skills selected'));
+          return;
+        }
+        
+        // Confirm breaking changes
+        const breakingChanges = selectedSkills.filter(s => s.hasBreakingChange);
+        if (breakingChanges.length > 0) {
+          console.log(chalk.yellow('\n⚠️  Breaking changes detected:'));
+          for (const skill of breakingChanges) {
+            console.log(`   - ${skill.name}`);
+          }
+          
+          const confirmed = await confirm({
+            message: 'These upgrades may have breaking changes. Continue?',
+            default: false
+          });
+          
+          if (!confirmed) {
+            console.log(chalk.gray('   Cancelled'));
+            return;
+          }
+        }
+        
+        // Perform upgrades
+        console.log(chalk.blue(`\n🔄 Upgrading ${selectedSkills.length} skill(s)...`));
+        
+        for (const skill of selectedSkills) {
+          await upgradeSkill(skill, skillsDir, lockfileManager);
+        }
+        
+        await lockfileManager.save();
+        
+        console.log(chalk.green(`\n✅ Successfully upgraded ${selectedSkills.length} skill(s)`));
+        
+      } catch (error) {
+        console.error(chalk.red(`❌ Upgrade failed: ${error.message}`));
+        process.exit(1);
+      }
+    });
+}
+
+async function findUpgradableSkills(lockfileManager, registryManager, skillsDir, specificSkill) {
+  const upgradable = [];
+  const installedSkills = lockfileManager.lockData.skills || {};
+  
+  // Also check sibling dir (.claude ↔ .agent)
+  const siblingDir = skillsDir.includes('.claude')
+    ? skillsDir.replace('.claude', '.agent')
+    : skillsDir.replace('.agent', '.claude');
+
+  const skillNames = specificSkill 
+    ? [specificSkill]
+    : Object.keys(installedSkills);
+  
+  for (const name of skillNames) {
+    const current = installedSkills[name];
+    if (!current) continue;
+    
+    // Check existence in either standard dir
+    const skillPath = [skillsDir, siblingDir].map(d => path.join(d, name)).find(p => fs.existsSync(p));
+    if (!skillPath) continue;
+    
+    let latestVersion = null;
+    let hasBreakingChange = false;
+    let changelog = '';
+    
+    // Check registry for updates
+    if (registryManager && registryManager.hasSkill(name)) {
+      const recommended = registryManager.getRecommendedVersion(name);
+      if (recommended && recommended.version !== current.version) {
+        latestVersion = recommended.version;
+        
+        // Check for breaking change (major version bump)
+        const currentMajor = parseInt(current.version.split('.')[0]);
+        const latestMajor = parseInt(latestVersion.split('.')[0]);
+        hasBreakingChange = latestMajor > currentMajor;
+        
+        if (recommended.changelog) {
+          changelog = recommended.changelog;
+        }
+      }
+    }
+    
+    // Check GitHub source for updates
+    if (!latestVersion && current.source === 'github' && current.repository) {
+      const remoteVersion = await checkGitHubForUpdates(current.repository, name);
+      if (remoteVersion && remoteVersion !== current.version) {
+        latestVersion = remoteVersion;
+        const currentMajor = parseInt(current.version.split('.')[0]);
+        const latestMajor = parseInt(latestVersion.split('.')[0]);
+        hasBreakingChange = latestMajor > currentMajor;
+      }
+    }
+    
+    if (latestVersion) {
+      upgradable.push({
+        name,
+        currentVersion: current.version,
+        latestVersion,
+        hasBreakingChange,
+        changelog,
+        source: current.source,
+        repository: current.repository
+      });
+    }
+  }
+  
+  return upgradable;
+}
+
+async function checkGitHubForUpdates(repository, skillName) {
+  try {
+    const [owner, repo] = repository.split('/');
+    const cacheKey = `${owner}-${repo}`;
+    const cachePath = path.join(CACHE_DIR, cacheKey);
+    
+    if (!fs.existsSync(cachePath)) {
+      return null;
+    }
+    
+    // Fetch latest from remote
+    const git = simpleGit(cachePath);
+    await git.fetch(['--depth', '1']);
+    
+    // Check for tags
+    const tags = await git.tags(['--sort=-version:refname']);
+    if (tags.all.length > 0) {
+      // Remove 'v' prefix if present
+      return tags.all[0].replace(/^v/, '');
+    }
+    
+    return null;
+  } catch (error) {
+    return null;
+  }
+}
+
+async function upgradeSkill(skill, skillsDir, lockfileManager) {
+  console.log(chalk.gray(`   Upgrading ${skill.name}...`));
+  
+  try {
+    if (skill.source === 'github' && skill.repository) {
+      // Re-install from GitHub
+      await upgradeFromGitHub(skill, skillsDir);
+    } else if (skill.source === 'registry') {
+      // Re-install from registry
+      await upgradeFromRegistry(skill, skillsDir);
+    }
+    
+    // Update lockfile
+    lockfileManager.updateSkill(skill.name, {
+      ...lockfileManager.getSkill(skill.name),
+      version: skill.latestVersion,
+      upgradedAt: new Date().toISOString()
+    });
+    
+    console.log(chalk.green(`   ✓ ${skill.name} upgraded to v${skill.latestVersion}`));
+  } catch (error) {
+    console.error(chalk.red(`   ✗ Failed to upgrade ${skill.name}: ${error.message}`));
+  }
+}
+
+async function upgradeFromGitHub(skill, skillsDir) {
+  const [owner, repo] = skill.repository.split('/');
+  const cacheKey = `${owner}-${repo}`;
+  const cachePath = path.join(CACHE_DIR, cacheKey);
+  
+  // Pull latest
+  const git = simpleGit(cachePath);
+  await git.pull();
+  
+  // Find skill in cache
+  const skillSourcePath = path.join(cachePath, skill.name);
+  if (!fs.existsSync(skillSourcePath)) {
+    throw new Error(`Skill not found in repository: ${skill.name}`);
+  }
+  
+  // Remove old version
+  const targetPath = path.join(skillsDir, skill.name);
+  if (fs.existsSync(targetPath)) {
+    fs.rmSync(targetPath, { recursive: true, force: true });
+  }
+  
+  // Copy new version
+  copyRecursive(skillSourcePath, targetPath);
+}
+
+async function upgradeFromRegistry(skill, skillsDir) {
+  // Implementation depends on registry structure
+  // For now, just update the version in lockfile
+  console.log(chalk.yellow(`   Note: Registry upgrade not fully implemented for ${skill.name}`));
+}
+
+function copyRecursive(src, dest) {
+  if (!fs.existsSync(dest)) {
+    fs.mkdirSync(dest, { recursive: true });
+  }
+  
+  const entries = fs.readdirSync(src, { withFileTypes: true });
+  
+  for (const entry of entries) {
+    const srcPath = path.join(src, entry.name);
+    const destPath = path.join(dest, entry.name);
+    
+    if (entry.isDirectory()) {
+      copyRecursive(srcPath, destPath);
+    } else {
+      fs.copyFileSync(srcPath, destPath);
+    }
+  }
+}