joyskills-cli 0.2.10 → 0.3.1

package/src/commands/update.js

@@ -0,0 +1,320 @@
+/**
+ * Update Command - 更新技能
+ */
+
+import { Command } from 'commander';
+import { getUpdatableSkills } from '../version-checker.js';
+import { SkillLoader } from '../skill-loader.js';
+import { LockfileManager } from '../lockfile.js';
+import simpleGit from 'simple-git';
+import chalk from 'chalk';
+import { confirm } from '@inquirer/prompts';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+
+export function updateCommand(program) {
+  program
+    .command('update [skills...]')
+    .description('Update installed skills to latest versions')
+    .option('-y, --yes', 'Skip confirmation prompts')
+    .option('-a, --all', 'Update all skills')
+    .action(async (skillNames, options) => {
+      try {
+        const projectRoot = process.cwd();
+        
+        console.log(chalk.blue('Updating skills...'));
+        console.log(chalk.gray('==================\n'));
+
+        // 获取要更新的 skills
+        let skillsToUpdate = [];
+        
+        if (options.all || skillNames.length === 0) {
+          // 更新所有有更新的 skills（Git + team://）
+          skillsToUpdate = await getAllUpdatableSkills(projectRoot);
+        } else {
+          // 更新指定的 skills
+          skillsToUpdate = await getSpecifiedSkills(projectRoot, skillNames);
+        }
+
+        if (skillsToUpdate.length === 0) {
+          console.log(chalk.green('✅ No skills to update.'));
+          return;
+        }
+
+        // 显示将要更新的 skills
+        console.log(chalk.cyan('Skills to update:'));
+        for (const skill of skillsToUpdate) {
+          console.log(`  📦 ${skill.name} (v${skill.currentVersion})`);
+        }
+        console.log();
+
+        // 确认
+        if (!options.yes) {
+          const shouldUpdate = await confirm({
+            message: `Update ${skillsToUpdate.length} skill(s)?`,
+            default: true,
+          });
+          
+          if (!shouldUpdate) {
+            console.log(chalk.gray('Update cancelled.'));
+            return;
+          }
+        }
+
+        // 执行更新
+        console.log(chalk.blue('\nUpdating...\n'));
+        
+        const results = [];
+        for (const skill of skillsToUpdate) {
+          try {
+            if (skill.type === 'team') {
+              // team:// 类型：重新安装
+              await updateTeamSkill(skill, projectRoot);
+            } else {
+              // Git 类型：pull
+              const git = simpleGit(skill.path);
+              await git.pull('origin', 'main', ['--depth', '1']);
+            }
+            
+            console.log(chalk.green(`✅ ${skill.name} updated to v${skill.latestVersion || 'latest'}`));
+            results.push({ name: skill.name, success: true });
+          } catch (e) {
+            console.log(chalk.red(`❌ ${skill.name} failed: ${e.message}`));
+            results.push({ name: skill.name, success: false, error: e.message });
+          }
+        }
+
+        // 总结
+        const successCount = results.filter(r => r.success).length;
+        const failCount = results.length - successCount;
+
+        console.log(chalk.gray('\n=================='));
+        console.log(chalk.green(`✅ Updated: ${successCount}`));
+        if (failCount > 0) {
+          console.log(chalk.red(`❌ Failed: ${failCount}`));
+        }
+
+      } catch (error) {
+        console.error(chalk.red('❌ Failed to update:'), error.message);
+        process.exit(1);
+      }
+    });
+}
+
+/**
+ * 获取所有可更新的 Skills（Git + team://）
+ */
+async function getAllUpdatableSkills(projectRoot) {
+  const updatable = [];
+  
+  // 1. 检查 Git 仓库类型的 Skills
+  const gitSkills = await getUpdatableSkills(projectRoot);
+  updatable.push(...gitSkills);
+  
+  // 2. 检查 team:// 类型的 Skills
+  const teamSkills = await getUpdatableTeamSkills(projectRoot);
+  updatable.push(...teamSkills);
+  
+  return updatable;
+}
+
+/**
+ * 更新 team:// 类型的 Skill
+ */
+async function updateTeamSkill(skill, projectRoot) {
+  const lockfile = new LockfileManager(projectRoot);
+  await lockfile.load();
+  
+  const updateInfo = await checkTeamSkillUpdate(skill, skill.source);
+  
+  if (!updateInfo.hasUpdate) {
+    throw new Error('No update available');
+  }
+  
+  // 删除旧版本
+  if (fs.existsSync(skill.path)) {
+    fs.rmSync(skill.path, { recursive: true, force: true });
+  }
+  
+  // 复制新版本
+  copyRecursive(updateInfo.registrySkillPath, skill.path);
+  
+  // 更新 lockfile
+  lockfile.updateSkill(skill.name, {
+    version: updateInfo.latestVersion,
+    source: skill.source,
+    updatedAt: new Date().toISOString(),
+  });
+  await lockfile.save();
+}
+
+/**
+ * 递归复制目录
+ */
+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);
+    }
+  }
+}
+
+/**
+ * 获取指定的 Skills
+ */
+async function getSpecifiedSkills(projectRoot, skillNames) {
+  const skills = [];
+  const loader = new SkillLoader(projectRoot);
+  const lockfile = new LockfileManager(projectRoot);
+  await lockfile.load();
+  
+  for (const name of skillNames) {
+    const skill = loader.getSkill(name);
+    if (!skill) {
+      console.log(chalk.red(`❌ Skill not found: ${name}`));
+      continue;
+    }
+    
+    const lockData = lockfile.getSkill(name);
+    
+    if (lockData?.source?.startsWith('team:')) {
+      // team:// 类型
+      const updateInfo = await checkTeamSkillUpdate(skill, lockData.source);
+      if (updateInfo.hasUpdate) {
+        skills.push({
+          name: skill.name,
+          path: skill.path,
+          currentVersion: skill.version,
+          latestVersion: updateInfo.latestVersion,
+          source: lockData.source,
+          type: 'team',
+        });
+      }
+    } else {
+      // Git 类型
+      const git = simpleGit(skill.path);
+      const isRepo = await git.checkIsRepo();
+      if (isRepo) {
+        const updateInfo = await checkGitSkillUpdate(skill);
+        if (updateInfo.hasUpdate) {
+          skills.push({
+            name: skill.name,
+            path: skill.path,
+            currentVersion: skill.version,
+            latestVersion: updateInfo.latestVersion,
+            source: lockData?.source || 'git',
+            type: 'git',
+          });
+        }
+      } else {
+        console.log(chalk.yellow(`⚠️  ${name} is not a git repository, skipping`));
+      }
+    }
+  }
+  
+  return skills;
+}
+
+/**
+ * 检查 team:// 类型的 Skill 是否有更新
+ */
+async function checkTeamSkillUpdate(skill, source) {
+  const registryName = source.replace('team:', '');
+  const JOYSKILL_CONFIG_DIR = process.env.JOYSKILL_CONFIG_DIR || path.join(os.homedir(), '.joyskill');
+  const configPath = path.join(JOYSKILL_CONFIG_DIR, 'config.json');
+  
+  if (!fs.existsSync(configPath)) {
+    return { hasUpdate: false, error: 'No registry config' };
+  }
+  
+  const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+  const reg = config.registries?.[registryName];
+  
+  if (!reg?.path || !fs.existsSync(reg.path)) {
+    return { hasUpdate: false, error: `Registry ${registryName} not found` };
+  }
+  
+  // 从 registry 查找最新版本
+  const { findSkills } = await import('./install.js');
+  const registrySkills = await findSkills(reg.path);
+  const registrySkill = registrySkills.find(s => s.name === skill.name);
+  
+  if (!registrySkill) {
+    return { hasUpdate: false, error: 'Skill not found in registry' };
+  }
+  
+  const hasUpdate = registrySkill.version && registrySkill.version !== skill.version;
+  
+  return {
+    hasUpdate,
+    latestVersion: registrySkill.version,
+    registryPath: reg.path,
+    registrySkillPath: registrySkill.path,
+  };
+}
+
+/**
+ * 检查 Git 类型的 Skill 是否有更新
+ */
+async function checkGitSkillUpdate(skill) {
+  const git = simpleGit(skill.path);
+  const isRepo = await git.checkIsRepo();
+  
+  if (!isRepo) {
+    return { hasUpdate: false, error: 'Not a git repository' };
+  }
+  
+  await git.fetch(['--depth', '1']);
+  const log = await git.log({ maxCount: 1 });
+  const latestCommit = log.latest;
+  
+  // 简化：如果有 fetch 成功，认为可能有更新
+  return {
+    hasUpdate: true,
+    latestVersion: latestCommit?.hash?.slice(0, 7) || 'latest',
+  };
+}
+
+/**
+ * 获取所有可更新的 team:// Skills
+ */
+async function getUpdatableTeamSkills(projectRoot) {
+  const updatable = [];
+  const loader = new SkillLoader(projectRoot);
+  const lockfile = new LockfileManager(projectRoot);
+  await lockfile.load();
+  
+  const allSkills = loader.loadAllSkills();
+  
+  for (const skill of allSkills) {
+    const lockData = lockfile.getSkill(skill.name);
+    if (lockData?.source?.startsWith('team:')) {
+      const updateInfo = await checkTeamSkillUpdate(skill, lockData.source);
+      if (updateInfo.hasUpdate) {
+        updatable.push({
+          name: skill.name,
+          path: skill.path,
+          currentVersion: skill.version,
+          latestVersion: updateInfo.latestVersion,
+          source: lockData.source,
+          type: 'team',
+          registrySkillPath: updateInfo.registrySkillPath,
+        });
+      }
+    }
+  }
+  
+  return updatable;
+}

package/src/commands/upgrade.js

@@ -23,9 +23,22 @@ export function upgradeCommand(program) {
         const projectRoot = process.cwd();
         const isGlobal = options.global;
         // Scan both standard dirs; upgrade will check all
+        // v2.0: Support all agent directories, joycode first
         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')];
+          ? [
+              path.join(os.homedir(), '.joycode', 'skills'),
+              path.join(os.homedir(), '.claude', 'skills'),
+              path.join(os.homedir(), '.agent', 'skills'),
+              path.join(os.homedir(), '.cursor', 'skills'),
+              path.join(os.homedir(), '.qoder', 'skills'),
+            ]
+          : [
+              path.join(projectRoot, '.joycode', 'skills'),
+              path.join(projectRoot, '.claude', 'skills'),
+              path.join(projectRoot, '.agent', 'skills'),
+              path.join(projectRoot, '.cursor', 'skills'),
+              path.join(projectRoot, '.qoder', 'skills'),
+            ];
         // Use first existing dir as primary, but pass all dirs to findUpgradableSkills
         const skillsDir = skillsDirs.find(d => fs.existsSync(d)) || skillsDirs[0];
         
@@ -143,10 +156,21 @@ async function findUpgradableSkills(lockfileManager, registryManager, skillsDir,
   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');
+  // v2.0: Check all sibling dirs
+  const siblingDirs = [
+    skillsDir.replace('.joycode', '.claude'),
+    skillsDir.replace('.joycode', '.agent'),
+    skillsDir.replace('.joycode', '.cursor'),
+    skillsDir.replace('.joycode', '.qoder'),
+    skillsDir.replace('.claude', '.joycode'),
+    skillsDir.replace('.claude', '.agent'),
+    skillsDir.replace('.claude', '.cursor'),
+    skillsDir.replace('.claude', '.qoder'),
+    skillsDir.replace('.agent', '.joycode'),
+    skillsDir.replace('.agent', '.claude'),
+    skillsDir.replace('.agent', '.cursor'),
+    skillsDir.replace('.agent', '.qoder'),
+  ].filter(d => d !== skillsDir);
 
   const skillNames = specificSkill 
     ? [specificSkill]
@@ -156,16 +180,41 @@ async function findUpgradableSkills(lockfileManager, registryManager, skillsDir,
     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));
+    // Check existence in all dirs
+    const allDirs = [skillsDir, ...siblingDirs];
+    const skillPath = allDirs.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)) {
+    // Check registry for updates (including team:// sources)
+    if (current.source?.startsWith('team:')) {
+      // Handle team:// protocol
+      const registryName = current.source.replace('team:', '');
+      const JOYSKILL_CONFIG_DIR = process.env.JOYSKILL_CONFIG_DIR || path.join(os.homedir(), '.joyskill');
+      const configPath = path.join(JOYSKILL_CONFIG_DIR, 'config.json');
+      
+      if (fs.existsSync(configPath)) {
+        const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+        const reg = config.registries?.[registryName];
+        
+        if (reg?.path && fs.existsSync(reg.path)) {
+          // Find skill in registry to get latest version
+          const { findSkills } = await import('../commands/install.js');
+          const skills = await findSkills(reg.path);
+          const skillInfo = skills.find(s => s.name === name);
+          
+          if (skillInfo?.version && skillInfo.version !== current.version) {
+            latestVersion = skillInfo.version;
+            const currentMajor = parseInt(current.version.split('.')[0]);
+            const latestMajor = parseInt(latestVersion.split('.')[0]);
+            hasBreakingChange = latestMajor > currentMajor;
+          }
+        }
+      }
+    } else if (registryManager && registryManager.hasSkill(name)) {
       const recommended = registryManager.getRecommendedVersion(name);
       if (recommended && recommended.version !== current.version) {
         latestVersion = recommended.version;
@@ -289,9 +338,50 @@ async function upgradeFromGitHub(skill, skillsDir) {
 }
 
 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}`));
+  // v2.0: Support team:// protocol upgrade
+  const JOYSKILL_CONFIG_DIR = process.env.JOYSKILL_CONFIG_DIR || path.join(os.homedir(), '.joyskill');
+  const configPath = path.join(JOYSKILL_CONFIG_DIR, 'config.json');
+  
+  if (!fs.existsSync(configPath)) {
+    throw new Error('No registry config found. Run: joySkills team add <name> <url>');
+  }
+  
+  const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+  const registries = config.registries || {};
+  
+  // Find registry by source (team:registryName)
+  const registryName = skill.source.replace('team:', '');
+  const reg = registries[registryName];
+  
+  if (!reg?.path || !fs.existsSync(reg.path)) {
+    throw new Error(`Registry "${registryName}" not found. Run: joySkills team list`);
+  }
+  
+  // Find skill in registry
+  const { findSkills } = await import('../commands/install.js');
+  const skills = await findSkills(reg.path);
+  const skillInfo = skills.find(s => s.name === skill.name);
+  
+  if (!skillInfo) {
+    throw new Error(`Skill "${skill.name}" not found in registry "${registryName}"`);
+  }
+  
+  // Check if version is newer
+  if (skillInfo.version && skillInfo.version <= skill.currentVersion) {
+    console.log(chalk.gray(`   ${skill.name} is already up to date`));
+    return;
+  }
+  
+  // 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(skillInfo.path, targetPath);
+  
+  console.log(chalk.green(`   ✓ Upgraded from registry ${registryName}`));
 }
 
 function copyRecursive(src, dest) {

package/src/index.js

@@ -14,6 +14,8 @@ import { syncCommand } from './commands/sync.js';
 import { upgradeCommand } from './commands/upgrade.js';
 import { readCommand } from './commands/read.js';
 import { manageCommand } from './commands/manage.js';
+import { checkCommand } from './commands/check.js';
+import { updateCommand } from './commands/update.js';
 
 const program = new Command();
 
@@ -33,6 +35,8 @@ syncCommand(program);
 upgradeCommand(program);
 readCommand(program);
 manageCommand(program);
+checkCommand(program);
+updateCommand(program);
 
 // Parse arguments
 program.parse();

package/src/installer.js

@@ -0,0 +1,190 @@
+/**
+ * Installer - Skill 安装器
+ * 支持 Symlink 和 Copy 两种模式
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import { execSync } from 'child_process';
+
+/**
+ * 安装方式枚举
+ */
+export const InstallMethod = {
+  SYMLINK: 'symlink',  // 符号链接（默认，单点更新）
+  COPY: 'copy',        // 复制文件
+};
+
+/**
+ * 检查是否支持符号链接
+ */
+export function supportsSymlink(targetDir) {
+  try {
+    // 尝试创建一个测试符号链接
+    const testLink = path.join(targetDir, '.symlink-test');
+    const testTarget = path.join(targetDir, '.symlink-target');
+    
+    // 清理旧的测试文件
+    if (fs.existsSync(testLink)) fs.unlinkSync(testLink);
+    if (fs.existsSync(testTarget)) fs.unlinkSync(testTarget);
+    
+    // 创建测试目标文件
+    fs.writeFileSync(testTarget, 'test');
+    
+    // 尝试创建符号链接
+    fs.symlinkSync(testTarget, testLink);
+    
+    // 清理
+    fs.unlinkSync(testLink);
+    fs.unlinkSync(testTarget);
+    
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+
+/**
+ * 复制目录（递归）
+ */
+export function copyRecursive(src, dest) {
+  // 如果目标已存在，先删除
+  if (fs.existsSync(dest)) {
+    fs.rmSync(dest, { recursive: true, force: true });
+  }
+
+  const stat = fs.statSync(src);
+  
+  if (stat.isDirectory()) {
+    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);
+      }
+    }
+  } else {
+    fs.copyFileSync(src, dest);
+  }
+}
+
+/**
+ * 创建符号链接（跨平台）
+ */
+export function createSymlink(target, linkPath) {
+  // 确保目标存在
+  if (!fs.existsSync(target)) {
+    throw new Error(`Target does not exist: ${target}`);
+  }
+
+  // 如果链接已存在，先删除
+  if (fs.existsSync(linkPath)) {
+    const stat = fs.lstatSync(linkPath);
+    if (stat.isSymbolicLink() || stat.isDirectory() || stat.isFile()) {
+      fs.rmSync(linkPath, { recursive: true, force: true });
+    }
+  }
+
+  // 确保父目录存在
+  const parentDir = path.dirname(linkPath);
+  if (!fs.existsSync(parentDir)) {
+    fs.mkdirSync(parentDir, { recursive: true });
+  }
+
+  // 创建符号链接
+  const isDir = fs.statSync(target).isDirectory();
+  fs.symlinkSync(target, linkPath, isDir ? 'dir' : 'file');
+}
+
+/**
+ * 安装 Skill
+ */
+export function installSkill(sourcePath, targetPath, method = InstallMethod.SYMLINK) {
+  // 确保源存在
+  if (!fs.existsSync(sourcePath)) {
+    throw new Error(`Source skill not found: ${sourcePath}`);
+  }
+
+  // 确保父目录存在
+  const parentDir = path.dirname(targetPath);
+  if (!fs.existsSync(parentDir)) {
+    fs.mkdirSync(parentDir, { recursive: true });
+  }
+
+  if (method === InstallMethod.SYMLINK) {
+    // 检查是否支持符号链接
+    if (!supportsSymlink(parentDir)) {
+      console.log('Symlink not supported, falling back to copy mode...');
+      copyRecursive(sourcePath, targetPath);
+    } else {
+      createSymlink(sourcePath, targetPath);
+    }
+  } else {
+    // Copy 模式
+    copyRecursive(sourcePath, targetPath);
+  }
+}
+
+/**
+ * 批量安装 Skills
+ */
+export function installSkills(skills, targetDir, method = InstallMethod.SYMLINK) {
+  const results = [];
+  
+  for (const skill of skills) {
+    try {
+      const targetPath = path.join(targetDir, skill.name);
+      installSkill(skill.path, targetPath, method);
+      results.push({
+        name: skill.name,
+        success: true,
+        method: fs.lstatSync(targetPath).isSymbolicLink() ? 'symlink' : 'copy',
+      });
+    } catch (e) {
+      results.push({
+        name: skill.name,
+        success: false,
+        error: e.message,
+      });
+    }
+  }
+  
+  return results;
+}
+
+/**
+ * 移除 Skill
+ */
+export function removeSkill(skillPath) {
+  if (!fs.existsSync(skillPath)) {
+    return false;
+  }
+
+  fs.rmSync(skillPath, { recursive: true, force: true });
+  return true;
+}
+
+/**
+ * 获取安装信息
+ */
+export function getInstallInfo(skillPath) {
+  if (!fs.existsSync(skillPath)) {
+    return null;
+  }
+
+  const stat = fs.lstatSync(skillPath);
+  
+  return {
+    exists: true,
+    isSymlink: stat.isSymbolicLink(),
+    target: stat.isSymbolicLink() ? fs.readlinkSync(skillPath) : null,
+    size: stat.size,
+    modified: stat.mtime,
+  };
+}