joyskills-cli 0.2.10 → 0.3.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "joyskills-cli",
-  "version": "0.2.10",
-  "description": "Team-level skill governance compatible with open skill / Claude Skills",
+  "version": "0.3.0",
+  "description": "JoySkills CLI v2.0 - Multi-agent skill management with JoyCode native support",
   "main": "src/index.js",
   "bin": {
     "joySkills": "src/index.js"
@@ -9,9 +9,16 @@
   "scripts": {
     "build": "echo 'No build needed for JavaScript version'",
     "start": "node src/index.js",
-    "test": "jest",
+    "test": "NODE_OPTIONS=--experimental-vm-modules jest",
     "dev": "node src/index.js"
   },
+  "jest": {
+    "testEnvironment": "node",
+    "transform": {},
+    "moduleNameMapper": {
+      "^(\\.{1,2}/.*)\\.js$": "$1"
+    }
+  },
   "keywords": [
     "claude",
     "skills",

package/src/agents.js

@@ -0,0 +1,198 @@
+/**
+ * Agent 配置系统 - 支持多编辑器
+ * 定义各编辑器的项目级和用户级 Skill 目录
+ */
+
+import * as os from 'os';
+import * as path from 'path';
+import * as fs from 'fs';
+
+/**
+ * Agent 定义
+ * id: 唯一标识
+ * name: 显示名称
+ * projectPath: 项目级目录（相对路径）
+ * globalPath: 用户级目录（绝对路径，使用 ~ 表示 home）
+ * detectFiles: 用于自动检测的文件/目录
+ */
+export const AGENTS = [
+  {
+    id: 'joycode',
+    name: 'JoyCode',
+    projectPath: '.joycode/skills',
+    globalPath: '~/.joycode/skills',
+    detectFiles: ['.joycode'],
+    priority: 100, // 最高优先级，默认使用
+  },
+  {
+    id: 'claude-code',
+    name: 'Claude Code',
+    projectPath: '.claude/skills',
+    globalPath: '~/.claude/skills',
+    detectFiles: ['.claude', '.claude-plugin'],
+    priority: 90,
+  },
+  {
+    id: 'cursor',
+    name: 'Cursor',
+    projectPath: '.agents/skills',
+    globalPath: '~/.cursor/skills',
+    detectFiles: ['.cursor', '.agents'],
+    priority: 80,
+  },
+  {
+    id: 'codex',
+    name: 'Codex',
+    projectPath: '.agents/skills',
+    globalPath: '~/.codex/skills',
+    detectFiles: ['.codex'],
+    priority: 70,
+  },
+  {
+    id: 'qoder',
+    name: 'Qoder',
+    projectPath: '.qoder/skills',
+    globalPath: '~/.qoder/skills',
+    detectFiles: ['.qoder'],
+    priority: 60,
+  },
+  {
+    id: 'opencode',
+    name: 'OpenCode',
+    projectPath: '.agents/skills',
+    globalPath: '~/.config/opencode/skills',
+    detectFiles: ['.opencode'],
+    priority: 50,
+  },
+  {
+    id: 'universal',
+    name: 'Universal',
+    projectPath: '.agents/skills',
+    globalPath: '~/.config/agents/skills',
+    detectFiles: ['.agents'],
+    priority: 10,
+  },
+];
+
+/**
+ * 获取 Agent 配置
+ */
+export function getAgent(agentId) {
+  return AGENTS.find(a => a.id === agentId) || AGENTS[0]; // 默认返回 joycode
+}
+
+/**
+ * 获取所有 Agent
+ */
+export function getAllAgents() {
+  return AGENTS;
+}
+
+/**
+ * 解析路径中的 ~ 为 home 目录
+ */
+export function resolvePath(pathWithTilde) {
+  if (pathWithTilde.startsWith('~/')) {
+    return path.join(os.homedir(), pathWithTilde.slice(2));
+  }
+  return pathWithTilde;
+}
+
+/**
+ * 获取 Agent 的项目级目录（绝对路径）
+ */
+export function getAgentProjectPath(agentId, projectRoot) {
+  const agent = getAgent(agentId);
+  return path.join(projectRoot, agent.projectPath);
+}
+
+/**
+ * 获取 Agent 的用户级目录（绝对路径）
+ */
+export function getAgentGlobalPath(agentId) {
+  const agent = getAgent(agentId);
+  return resolvePath(agent.globalPath);
+}
+
+/**
+ * 检测项目中存在的 Agent
+ * 返回按优先级排序的 Agent ID 列表
+ */
+export function detectAgents(projectRoot) {
+  const detected = [];
+  
+  for (const agent of AGENTS) {
+    // 检查项目级目录是否存在
+    const projectPath = getAgentProjectPath(agent.id, projectRoot);
+    if (fs.existsSync(projectPath)) {
+      detected.push(agent.id);
+      continue;
+    }
+    
+    // 检查检测文件是否存在
+    for (const detectFile of agent.detectFiles) {
+      const detectPath = path.join(projectRoot, detectFile);
+      if (fs.existsSync(detectPath)) {
+        detected.push(agent.id);
+        break;
+      }
+    }
+  }
+  
+  // 按优先级排序
+  detected.sort((a, b) => {
+    const agentA = getAgent(a);
+    const agentB = getAgent(b);
+    return agentB.priority - agentA.priority;
+  });
+  
+  return detected;
+}
+
+/**
+ * 获取默认 Agent
+ * 始终返回 joycode 作为默认，不管检测到什么其他 Agent
+ * 这是 JoyCode 的品牌策略
+ */
+export function getDefaultAgent(projectRoot) {
+  // 始终返回 joycode 作为默认
+  return getAgent('joycode');
+}
+
+/**
+ * 获取所有 Skill 目录（项目级 + 用户级）
+ * 用于 SkillLoader 加载
+ */
+export function getAllSkillPaths(projectRoot, agentId = null) {
+  const paths = [];
+  const agents = agentId ? [getAgent(agentId)] : AGENTS;
+  
+  for (const agent of agents) {
+    // 项目级目录
+    const projectPath = getAgentProjectPath(agent.id, projectRoot);
+    if (fs.existsSync(projectPath)) {
+      paths.push({
+        path: projectPath,
+        scope: 'project',
+        agent: agent.id,
+        priority: agent.priority,
+      });
+    }
+    
+    // 用户级目录
+    const globalPath = getAgentGlobalPath(agent.id);
+    if (fs.existsSync(globalPath)) {
+      paths.push({
+        path: globalPath,
+        scope: 'global',
+        agent: agent.id,
+        priority: agent.priority - 1, // 用户级优先级略低
+      });
+    }
+  }
+  
+  // 按优先级排序
+  paths.sort((a, b) => b.priority - a.priority);
+  
+  return paths;
+}

package/src/commands/check.js

@@ -0,0 +1,69 @@
+/**
+ * Check Command - 检查技能更新
+ */
+
+import { Command } from 'commander';
+import { checkAllSkills, getUpdatableSkills } from '../version-checker.js';
+import chalk from 'chalk';
+
+export function checkCommand(program) {
+  program
+    .command('check')
+    .description('Check for available skill updates')
+    .option('-u, --updatable', 'Show only skills with updates')
+    .action(async (options) => {
+      try {
+        const projectRoot = process.cwd();
+        
+        console.log(chalk.blue('Checking for skill updates...'));
+        console.log(chalk.gray('==============================\n'));
+
+        const results = options.updatable 
+          ? await getUpdatableSkills(projectRoot)
+          : await checkAllSkills(projectRoot);
+
+        if (results.length === 0) {
+          if (options.updatable) {
+            console.log(chalk.green('✅ All skills are up to date!'));
+          } else {
+            console.log(chalk.yellow('No skills found.'));
+          }
+          return;
+        }
+
+        let updatableCount = 0;
+
+        for (const result of results) {
+          if (result.hasUpdate) {
+            updatableCount++;
+            console.log(chalk.yellow(`📦 ${result.name}`));
+            console.log(`   Current: v${result.currentVersion}`);
+            console.log(chalk.green(`   ${result.commitsBehind} commit(s) behind`));
+            if (result.latestCommit) {
+              console.log(chalk.gray(`   Latest: ${result.latestCommit.message.substring(0, 50)}...`));
+            }
+            console.log();
+          } else if (!options.updatable) {
+            console.log(chalk.green(`✅ ${result.name} v${result.currentVersion}`));
+            if (result.error) {
+              console.log(chalk.gray(`   ${result.error}`));
+            } else {
+              console.log(chalk.gray('   Up to date'));
+            }
+            console.log();
+          }
+        }
+
+        if (updatableCount > 0) {
+          console.log(chalk.blue(`\nFound ${updatableCount} skill(s) with updates.`));
+          console.log(chalk.gray('Run `joySkills update` to update all skills.'));
+        } else if (!options.updatable) {
+          console.log(chalk.green('\n✅ All skills are up to date!'));
+        }
+
+      } catch (error) {
+        console.error(chalk.red('❌ Failed to check updates:'), error.message);
+        process.exit(1);
+      }
+    });
+}

package/src/commands/install.js

@@ -2,6 +2,8 @@ import { Command } from 'commander';
 import { LocalManager } from '../local.js';
 import { LockfileManager } from '../lockfile.js';
 import { RegistryManager } from '../registry.js';
+import { getAgent, getAgentProjectPath, getAgentGlobalPath, detectAgents } from '../agents.js';
+import { installSkill, InstallMethod } from '../installer.js';
 import simpleGit from 'simple-git';
 import * as fs from 'fs';
 import * as path from 'path';
@@ -15,25 +17,22 @@ const CACHE_DIR = process.env.JOYSKILL_CACHE_DIR || path.join(os.homedir(), '.jo
 export function installCommand(program) {
   program
     .command('install [skill]')
+    .alias('add')
     .description('Install a skill from registry or GitHub')
     .option('-v, --version <version>', 'Specify version to install')
     .option('-r, --registry <name>', 'Install from specific registry')
-    .option('-g, --global', 'Install globally to ~/.claude/skills')
-    .option('--universal', 'Install to .agent/skills/ (multi-agent compatible)')
+    .option('-g, --global', 'Install to user-level directory (~/.joycode/skills/)')
+    .option('-a, --agent <agent>', 'Target specific agent (joycode, claude-code, cursor, etc.)')
+    .option('-d, --dir <path>', 'Install to custom directory')
+    .option('--copy', 'Copy files instead of symlinking')
     .option('--force', 'Force installation even if version is not recommended')
     .option('-y, --yes', 'Skip all prompts (CI mode)')
     .action(async (skillInput, options) => {
       try {
         const projectRoot = process.cwd();
-        // Directory resolution (matches openskill priority)
-        // --global  → ~/.claude/skills
-        // --universal → .agent/skills/
-        // default   → .claude/skills/
-        const targetDir = options.global
-          ? path.join(os.homedir(), '.claude', 'skills')
-          : options.universal
-            ? path.join(projectRoot, '.agent', 'skills')
-            : path.join(projectRoot, '.claude', 'skills');
+        
+        // 解析目标目录
+        const targetDir = resolveTargetDir(projectRoot, options);
         
         if (!fs.existsSync(targetDir)) {
           fs.mkdirSync(targetDir, { recursive: true });
@@ -54,6 +53,35 @@ export function installCommand(program) {
     });
 }
 
+/**
+ * 解析目标目录
+ * 优先级: --dir > --agent > --global > 默认(joycode)
+ */
+function resolveTargetDir(projectRoot, options) {
+  // 1. 自定义目录最高优先级
+  if (options.dir) {
+    return path.resolve(options.dir);
+  }
+
+  // 2. 指定 Agent
+  if (options.agent) {
+    const agent = getAgent(options.agent);
+    if (options.global) {
+      return getAgentGlobalPath(agent.id);
+    }
+    return getAgentProjectPath(agent.id, projectRoot);
+  }
+
+  // 3. 仅 --global，使用 joycode 用户级目录
+  if (options.global) {
+    return getAgentGlobalPath('joycode');
+  }
+
+  // 4. 默认: 始终使用 joycode 项目级目录
+  // 这是 JoyCode 的品牌策略，不随检测到的其他 Agent 改变
+  return getAgentProjectPath('joycode', projectRoot);
+}
+
 /**
  * Priority resolution chain:
  * 1. Local absolute/relative path
@@ -65,10 +93,24 @@ async function resolveAndInstall(skillInput, targetDir, projectRoot, options) {
   const JOYSKILL_CONFIG_DIR = process.env.JOYSKILL_CONFIG_DIR || path.join(os.homedir(), '.joyskill');
 
   // ── Step 0: Direct Git URL (git@xxx or https://github.com/...) ─────────
+  // Support: git@host:org/repo.git or git@host:org/repo.git/subpath
   if (skillInput.startsWith('git@') || skillInput.startsWith('https://') || skillInput.startsWith('http://')) {
-    // Normalize: ensure URL ends with .git for cloning
-    const gitUrl = skillInput.endsWith('.git') ? skillInput : skillInput + '.git';
-    await installFromGitUrl(gitUrl, targetDir, options);
+    // Parse URL and optional subpath
+    // Format: git@host:org/repo.git/subpath/to/skill
+    let gitUrl = skillInput;
+    let subPath = '';
+    
+    // Check for subpath after .git
+    const gitExtMatch = skillInput.match(/^(.+?\.git)(\/.*)$/);
+    if (gitExtMatch) {
+      gitUrl = gitExtMatch[1];
+      subPath = gitExtMatch[2].replace(/^\//, ''); // Remove leading slash
+    } else if (!skillInput.endsWith('.git')) {
+      // No .git extension, treat entire input as URL
+      gitUrl = skillInput;
+    }
+    
+    await installFromGitUrl(gitUrl, targetDir, options, subPath);
     return;
   }
 
@@ -151,13 +193,26 @@ async function resolveAndInstall(skillInput, targetDir, projectRoot, options) {
 
   // ── Fallback: create template ────────────────────────────────────
   console.log(chalk.yellow(`⚠️  "${skillInput}" not found in any registry, creating template...`));
-  const localManager = new LocalManager(projectRoot);
+  
+  // 使用 targetDir 安装模板
+  const skillPath = path.join(targetDir, skillInput);
+  if (!fs.existsSync(skillPath)) {
+    fs.mkdirSync(skillPath, { recursive: true });
+  }
+  
+  const skillMdPath = path.join(skillPath, 'SKILL.md');
+  fs.writeFileSync(skillMdPath, generateSkillTemplate(skillInput));
+  
   const lockfileManager = new LockfileManager(projectRoot);
-  localManager.installSkill(skillInput, generateSkillTemplate(skillInput));
   await lockfileManager.load();
-  lockfileManager.updateSkill(skillInput, { version: '1.0.0', source: 'template', installedAt: new Date().toISOString() });
+  lockfileManager.updateSkill(skillInput, { 
+    version: '1.0.0', 
+    source: 'template', 
+    path: skillPath,
+    installedAt: new Date().toISOString() 
+  });
   await lockfileManager.save();
-  console.log(chalk.green(`✅ Created template for ${skillInput}`));
+  console.log(chalk.green(`✅ Created template for ${skillInput} in ${targetDir}`));
 }
 
 /**
@@ -188,7 +243,14 @@ async function tryInstallFromRegistryDir(skillName, registryDirPath, targetDir,
       if (!fs.existsSync(sourcePath)) return false;
 
       const targetPath = path.join(targetDir, skillName);
-      copyRecursive(sourcePath, targetPath);
+      
+      // 使用新的 installer 模块，支持 symlink/copy
+      const method = options.copy ? InstallMethod.COPY : InstallMethod.SYMLINK;
+      installSkill(sourcePath, targetPath, method);
+      
+      // 获取安装方式信息
+      const installInfo = fs.lstatSync(targetPath);
+      const installMethod = installInfo.isSymbolicLink() ? 'symlink' : 'copy';
 
       const lockfileManager = new LockfileManager(projectRoot);
       await lockfileManager.load();
@@ -196,11 +258,13 @@ async function tryInstallFromRegistryDir(skillName, registryDirPath, targetDir,
         version,
         source: sourceLabel,
         registry: registryManager.getRegistryInfo().registryId,
+        installMethod,
         installedAt: new Date().toISOString()
       });
       await lockfileManager.save();
 
-      console.log(chalk.green(`✅ Installed ${skillName} v${version} from ${sourceLabel}`));
+      const methodLabel = installMethod === 'symlink' ? chalk.gray('(symlink)') : chalk.gray('(copy)');
+      console.log(chalk.green(`✅ Installed ${skillName} v${version} from ${sourceLabel}`) + ' ' + methodLabel);
       return true;
     } catch (e) {
       return false;
@@ -346,7 +410,7 @@ async function installFromLocalPath(localPath, targetDir, options) {
   }
 }
 
-async function installFromGitUrl(gitUrl, targetDir, options) {
+async function installFromGitUrl(gitUrl, targetDir, options, subPath = '') {
   // Derive cache key from URL
   const cacheKey = gitUrl
     .replace(/^git@/, '')
@@ -355,8 +419,12 @@ async function installFromGitUrl(gitUrl, targetDir, options) {
     .replace(/[:/]/g, '-');
 
   const cachePath = path.join(CACHE_DIR, cacheKey);
+  const sourcePath = subPath ? path.join(cachePath, subPath) : cachePath;
 
   console.log(chalk.blue(`📦 Installing from: ${gitUrl}`));
+  if (subPath) {
+    console.log(chalk.gray(`   Subpath: ${subPath}`));
+  }
 
   // Check if cache is valid (non-empty)
   const cacheValid = fs.existsSync(cachePath) && fs.readdirSync(cachePath).length > 0;
@@ -387,7 +455,7 @@ async function installFromGitUrl(gitUrl, targetDir, options) {
     }
   }
 
-  const skills = await findSkills(cachePath);
+  const skills = await findSkills(sourcePath);
   if (skills.length === 0) throw new Error('No skills found in repository');
 
   console.log(chalk.green(`   Found ${skills.length} skill(s)`));