joyskills-cli 0.2.9 → 0.3.0

package/src/commands/list.js

@@ -1,149 +1,91 @@
-import { RegistryManager } from '../registry.js';
-import { LockfileManager } from '../lockfile.js';
-import * as path from 'path';
-import * as fs from 'fs';
-import * as os from 'os';
+import { SkillLoader } from '../skill-loader.js';
 import chalk from 'chalk';
 
-/** Scan all standard skill directories and return unique skill names */
-function scanAllSkillDirs(projectRoot) {
-  const dirs = [
-    path.join(projectRoot, '.agent', 'skills'),
-    path.join(projectRoot, '.claude', 'skills'),
-    path.join(os.homedir(), '.agent', 'skills'),
-    path.join(os.homedir(), '.claude', 'skills'),
-    path.join(projectRoot, 'skills'), // legacy
-  ];
-  const seen = new Set();
-  const skills = [];
-  for (const dir of dirs) {
-    if (!fs.existsSync(dir)) continue;
-    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
-      if (entry.isDirectory() && !seen.has(entry.name)) {
-        seen.add(entry.name);
-        const skillMd = path.join(dir, entry.name, 'SKILL.md');
-        let description = '', version = '';
-        if (fs.existsSync(skillMd)) {
-          const content = fs.readFileSync(skillMd, 'utf-8');
-          description = (content.match(/description:\s*(.+)/) || [])[1]?.trim() || '';
-          version = (content.match(/version:\s*(.+)/) || [])[1]?.trim() || '';
-        }
-        skills.push({ name: entry.name, dir, description, version });
-      }
-    }
-  }
-  return skills;
-}
-
 export function listCommand(program) {
   program
     .command('list')
-    .description('List available skills')
-    .option('-a, --all-versions', 'Show all versions of each skill')
-    .option('-c, --category <category>', 'Filter by category')
+    .alias('ls')
+    .description('List installed skills')
+    .option('-a, --agent <agent>', 'Filter by agent (joycode, claude-code, cursor, etc.)')
+    .option('-g, --global', 'Show only global (user-level) skills')
+    .option('-p, --project', 'Show only project-level skills')
     .option('-s, --search <query>', 'Search skills by name or description')
-    .option('-i, --installed', 'Show only installed skills')
-    .option('-l, --local', 'Show only local skills')
-    .option('-r, --registry <name>', 'Show skills from specific registry')
+    .option('--stats', 'Show statistics')
     .action(async (options) => {
       const projectRoot = process.cwd();
-      const lockfileManager = new LockfileManager(projectRoot);
-
-      console.log(chalk.blue('Available Skills:'));
-      console.log(chalk.gray('================='));
+      const loader = new SkillLoader(projectRoot);
 
       try {
-        await lockfileManager.load();
-        const installedSkills = lockfileManager.lockData.skills;
-
-        // Scan all skill directories
-        const localSkills = scanAllSkillDirs(projectRoot);
-
-        if (!options.registry) {
-          if (localSkills.length > 0) {
-            console.log(chalk.blue('\nInstalled Skills:'));
-            let filtered = localSkills;
-            if (options.search) {
-              const q = options.search.toLowerCase();
-              filtered = filtered.filter(s => s.name.toLowerCase().includes(q) || s.description.toLowerCase().includes(q));
-            }
-            if (filtered.length > 0) {
-              filtered.forEach(skill => {
-                const lock = installedSkills[skill.name];
-                const ver = lock ? chalk.gray(`v${lock.version}`) : (skill.version ? chalk.gray(`v${skill.version}`) : '');
-                const src = lock ? chalk.gray(`[${lock.source}]`) : '';
-                console.log(`  ✅ ${chalk.bold(skill.name)} ${ver} ${src}`);
-                if (skill.description) console.log(`     ${chalk.gray(skill.description)}`);
-              });
-            } else {
-              console.log('  No matching skills found.');
-            }
-          } else {
-            console.log(chalk.yellow('\n  No skills installed.'));
-            console.log(chalk.gray('  Run: joySkills install <skill>'));
-          }
+        // 加载 skills
+        let skills = [];
+        if (options.global) {
+          skills = loader.loadGlobalSkills(options.agent);
+        } else if (options.project) {
+          skills = loader.loadProjectSkills(options.agent);
+        } else {
+          skills = loader.loadAllSkills(options.agent);
         }
 
-        // Check for registry
-        const registryPath = path.join(projectRoot, '.joyskill/registry');
-        if (fs.existsSync(registryPath) && !options.local) {
-          try {
-            const registryManager = new RegistryManager(registryPath);
-            await registryManager.load();
+        // 搜索过滤
+        if (options.search) {
+          const q = options.search.toLowerCase();
+          skills = skills.filter(s => 
+            s.name.toLowerCase().includes(q) || 
+            s.description.toLowerCase().includes(q)
+          );
+        }
 
-            console.log('\nRegistry Skills:');
+        // 统计模式
+        if (options.stats) {
+          const stats = loader.getStats(options.agent);
+          console.log(chalk.blue('\nSkill Statistics:'));
+          console.log(chalk.gray('=================='));
+          console.log(`  Total: ${stats.total}`);
+          console.log(`  Project-level: ${stats.project}`);
+          console.log(`  Global: ${stats.global}`);
+          console.log(`  Agents: ${stats.agents.join(', ')}`);
+          return;
+        }
 
-            let skills = registryManager.getAllSkills();
+        // 显示 skills
+        console.log(chalk.blue('\nInstalled Skills:'));
+        console.log(chalk.gray('=================='));
 
-            // Apply filters
-            if (options.category) {
-              skills = registryManager.getSkillsByCategory(options.category);
-            }
+        if (skills.length === 0) {
+          console.log(chalk.yellow('  No skills found.'));
+          console.log(chalk.gray('  Run: joySkills install <skill>'));
+          return;
+        }
 
-            if (options.search) {
-              skills = registryManager.searchSkills(options.search);
-            }
+        // 按 scope 分组显示
+        const projectSkills = skills.filter(s => s.scope === 'project');
+        const globalSkills = skills.filter(s => s.scope === 'global');
 
-            if (options.installed) {
-              skills = skills.filter(skill => installedSkills[skill.id]);
+        if (projectSkills.length > 0 && !options.global) {
+          console.log(chalk.cyan('\n  📁 Project-level:'));
+          projectSkills.forEach(skill => {
+            const scopeLabel = skill.agent === 'joycode' ? '' : chalk.gray(`[${skill.agent}]`);
+            console.log(`    ✅ ${chalk.bold(skill.name)} ${chalk.gray(`v${skill.version}`)} ${scopeLabel}`);
+            if (skill.description) {
+              console.log(`       ${chalk.gray(skill.description)}`);
             }
+          });
+        }
 
-            if (skills.length > 0) {
-              skills.forEach(skill => {
-                const isInstalled = installedSkills[skill.id] ? '✅' : '  ';
-                const installedVersion = installedSkills[skill.id]?.version;
-
-                // Get recommended version
-                const recommended = registryManager.getRecommendedVersion(skill.id);
-                const recommendedVersion = recommended ? recommended.version : 'N/A';
-
-                console.log(`  ${isInstalled} ${skill.name || skill.id} (${skill.id})`);
-                if (options.allVersions) {
-                  skill.versions.forEach(v => {
-                    const marker = v.recommended ? '⭐' : '  ';
-                    const state = v.state === 'approved' ? '✓' : v.state;
-                    console.log(`      ${marker} v${v.version} [${state}]`);
-                  });
-                } else {
-                  console.log(`      Recommended: v${recommendedVersion}`);
-                  if (installedVersion) {
-                    console.log(`      Installed: v${installedVersion}`);
-                  }
-                }
-                if (skill.description) {
-                  console.log(`      ${skill.description}`);
-                }
-                console.log('');
-              });
-            } else {
-              console.log('  No matching registry skills found.');
+        if (globalSkills.length > 0 && !options.project) {
+          console.log(chalk.cyan('\n  🏠 Global (user-level):'));
+          globalSkills.forEach(skill => {
+            const scopeLabel = skill.agent === 'joycode' ? '' : chalk.gray(`[${skill.agent}]`);
+            console.log(`    ✅ ${chalk.bold(skill.name)} ${chalk.gray(`v${skill.version}`)} ${scopeLabel}`);
+            if (skill.description) {
+              console.log(`       ${chalk.gray(skill.description)}`);
             }
-          } catch (error) {
-            console.error('Error loading registry:', error.message);
-          }
+          });
         }
+
+        console.log(chalk.gray(`\n  Total: ${skills.length} skill(s)`));
       } catch (error) {
-        console.error('Error listing skills:', error);
+        console.error(chalk.red('Error listing skills:'), error.message);
       }
     });
 }

package/src/commands/remove.js

@@ -5,12 +5,21 @@ import * as os from 'os';
 import chalk from 'chalk';
 
 function findSkillOnDisk(skillName, projectRoot) {
+  // v2.0: Support all agent directories, joycode first
   const dirs = [
+    // Project-level
+    path.join(projectRoot, '.joycode', 'skills'),
     path.join(projectRoot, '.agent', 'skills'),
     path.join(projectRoot, '.claude', 'skills'),
+    path.join(projectRoot, '.cursor', 'skills'),
+    path.join(projectRoot, '.qoder', 'skills'),
+    path.join(projectRoot, 'skills'),
+    // Global
+    path.join(os.homedir(), '.joycode', 'skills'),
     path.join(os.homedir(), '.agent', 'skills'),
     path.join(os.homedir(), '.claude', 'skills'),
-    path.join(projectRoot, 'skills'),
+    path.join(os.homedir(), '.cursor', 'skills'),
+    path.join(os.homedir(), '.qoder', 'skills'),
   ];
   for (const d of dirs) {
     const p = path.join(d, skillName);
@@ -23,7 +32,8 @@ export function removeCommand(program) {
   program
     .command('remove <skill>')
     .description('Remove a skill')
-    .action(async (skillName) => {
+    .option('-y, --yes', 'Skip confirmation prompt')
+    .action(async (skillName, options) => {
       const projectRoot = process.cwd();
       const lockfileManager = new LockfileManager(projectRoot);
 

package/src/commands/sync.js

@@ -20,12 +20,18 @@ export function syncCommand(program) {
 
         console.log(chalk.blue('🔍 Scanning skills...'));
 
-        // Scan all skill directories (openskill priority order)
+        // Scan project-level skill directories only (v2.0)
+        // AGENTS.md should only reference project-level skills
         const skillDirs = [
+          // JoyCode (default, highest priority)
+          { path: path.join(projectRoot, '.joycode', 'skills'), label: 'joycode' },
+          // Universal (multi-agent compatible)
           { path: path.join(projectRoot, '.agent', 'skills'), label: 'universal' },
-          { path: path.join(projectRoot, '.claude', 'skills'), label: 'project' },
-          { path: path.join(os.homedir(), '.agent', 'skills'), label: 'global-universal' },
-          { path: path.join(os.homedir(), '.claude', 'skills'), label: 'global' },
+          // Claude Code
+          { path: path.join(projectRoot, '.claude', 'skills'), label: 'claude' },
+          // Other agents
+          { path: path.join(projectRoot, '.cursor', 'skills'), label: 'cursor' },
+          { path: path.join(projectRoot, '.qoder', 'skills'), label: 'qoder' },
           // legacy
           { path: path.join(projectRoot, 'skills'), label: 'legacy' },
         ];

package/src/commands/update.js

@@ -0,0 +1,114 @@
+/**
+ * Update Command - 更新技能
+ */
+
+import { Command } from 'commander';
+import { getUpdatableSkills } from '../version-checker.js';
+import { SkillLoader } from '../skill-loader.js';
+import simpleGit from 'simple-git';
+import chalk from 'chalk';
+import { confirm } from '@inquirer/prompts';
+
+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
+          const updatable = await getUpdatableSkills(projectRoot);
+          skillsToUpdate = updatable;
+        } else {
+          // 更新指定的 skills
+          const loader = new SkillLoader(projectRoot);
+          for (const name of skillNames) {
+            const skill = loader.getSkill(name);
+            if (skill) {
+              const git = simpleGit(skill.path);
+              const isRepo = await git.checkIsRepo();
+              if (isRepo) {
+                skillsToUpdate.push({
+                  name: skill.name,
+                  path: skill.path,
+                  currentVersion: skill.version,
+                });
+              } else {
+                console.log(chalk.yellow(`⚠️  ${name} is not a git repository, skipping`));
+              }
+            } else {
+              console.log(chalk.red(`❌ Skill not found: ${name}`));
+            }
+          }
+        }
+
+        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 {
+            const git = simpleGit(skill.path);
+            
+            // 拉取最新代码
+            await git.pull('origin', 'main', ['--depth', '1']);
+            
+            console.log(chalk.green(`✅ ${skill.name} updated successfully`));
+            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);
+      }
+    });
+}

package/src/commands/upgrade.js

@@ -269,9 +269,12 @@ async function upgradeFromGitHub(skill, skillsDir) {
   const git = simpleGit(cachePath);
   await git.pull();
   
-  // Find skill in cache
-  const skillSourcePath = path.join(cachePath, skill.name);
-  if (!fs.existsSync(skillSourcePath)) {
+  // Find skill in cache (support nested directories)
+  const { findSkills } = await import('../commands/install.js');
+  const skills = await findSkills(cachePath);
+  const skillInfo = skills.find(s => s.name === skill.name);
+  
+  if (!skillInfo) {
     throw new Error(`Skill not found in repository: ${skill.name}`);
   }
   
@@ -282,7 +285,7 @@ async function upgradeFromGitHub(skill, skillsDir) {
   }
   
   // Copy new version
-  copyRecursive(skillSourcePath, targetPath);
+  copyRecursive(skillInfo.path, targetPath);
 }
 
 async function upgradeFromRegistry(skill, skillsDir) {

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,
+  };
+}