joyskills-cli 0.3.3 → 0.3.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "joyskills-cli",
-  "version": "0.3.3",
+  "version": "0.3.5",
   "description": "JoySkills CLI v2.0 - Multi-agent skill management with JoyCode native support",
   "main": "src/index.js",
   "bin": {

package/src/commands/check.js

@@ -3,7 +3,8 @@
  */
 
 import { Command } from 'commander';
-import { checkAllSkills, getUpdatableSkills } from '../version-checker.js';
+import { checkAllSkills, getUpdatableSkills, checkSkill } from '../version-checker.js';
+import { SkillLoader } from '../skill-loader.js';
 import chalk from 'chalk';
 
 export function checkCommand(program) {
@@ -11,6 +12,8 @@ export function checkCommand(program) {
     .command('check')
     .description('Check for available skill updates')
     .option('-u, --updatable', 'Show only skills with updates')
+    .option('-g, --global', 'Check global (user-level) skills only')
+    .option('-p, --project', 'Check project-level skills only')
     .action(async (options) => {
       try {
         const projectRoot = process.cwd();
@@ -19,8 +22,8 @@ export function checkCommand(program) {
         console.log(chalk.gray('==============================\n'));
 
         const results = options.updatable 
-          ? await getUpdatableSkills(projectRoot)
-          : await checkAllSkills(projectRoot);
+          ? await getUpdatableSkills(projectRoot, options.global, options.project)
+          : await checkAllSkills(projectRoot, options.global, options.project);
 
         if (results.length === 0) {
           if (options.updatable) {

package/src/commands/install.js

@@ -8,12 +8,123 @@ import simpleGit from 'simple-git';
 import * as fs from 'fs';
 import * as path from 'path';
 import * as os from 'os';
-import { select, confirm } from '@inquirer/prompts';
+import { select, confirm, input } 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');
+
 // Cache directory for cloned repos
 const CACHE_DIR = process.env.JOYSKILL_CACHE_DIR || path.join(os.homedir(), '.joyskill', 'cache');
 
+/**
+ * Check if a registry exists in global config
+ */
+function registryExists(registryName) {
+  const configPath = path.join(JOYSKILL_DIR, 'config.json');
+  if (!fs.existsSync(configPath)) return false;
+  
+  try {
+    const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+    return config.registries && config.registries[registryName];
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Add a registry to global config (used by auto-prompt)
+ */
+async function addRegistryInteractive(registryName, suggestedUrl = null) {
+  console.log(chalk.yellow(`\n⚠️  Registry '${registryName}' not found in local config.`));
+  console.log(chalk.gray(`   This skill is from a team registry. Please add it first.`));
+  
+  let gitUrl = suggestedUrl;
+  
+  if (!gitUrl) {
+    gitUrl = await input({
+      message: `Enter the Git URL for registry '${registryName}':`,
+      validate: (value) => {
+        if (!value) return 'Git URL is required';
+        if (!value.includes('@') && !value.startsWith('http')) {
+          return 'Please enter a valid Git URL (SSH or HTTPS)';
+        }
+        return true;
+      }
+    });
+  }
+  
+  console.log(chalk.blue(`\n📦 Adding team registry: ${registryName}`));
+  console.log(chalk.gray(`   URL: ${gitUrl}`));
+  
+  // Clone registry to cache
+  const registryCachePath = path.join(REGISTRY_CACHE_DIR, registryName);
+  
+  if (fs.existsSync(registryCachePath)) {
+    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']);
+  
+  // 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'));
+  }
+  
+  config.registries[registryName] = {
+    url: gitUrl,
+    path: registryCachePath,
+    addedAt: new Date().toISOString()
+  };
+  
+  fs.mkdirSync(JOYSKILL_DIR, { recursive: true });
+  fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+  
+  console.log(chalk.green(`   ✓ Added registry '${registryName}'`));
+  
+  return registryCachePath;
+}
+
+/**
+ * Get registry path with auto-prompt for missing registries
+ */
+async function getRegistryPathWithPrompt(registryName, options = {}) {
+  if (!registryExists(registryName)) {
+    if (options.yes || process.env.CI) {
+      throw new Error(`Registry '${registryName}' not found. Run: joySkills team add ${registryName} <git-url>`);
+    }
+    
+    // Auto-prompt to add registry
+    await addRegistryInteractive(registryName);
+  }
+  
+  const configPath = path.join(JOYSKILL_DIR, 'config.json');
+  const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+  return config.registries[registryName].path;
+}
+
+/**
+ * Get git commit hash for a directory
+ */
+async function getGitCommit(dirPath) {
+  try {
+    const git = simpleGit(dirPath);
+    const isRepo = await git.checkIsRepo();
+    if (!isRepo) return null;
+    
+    const log = await git.log({ maxCount: 1 });
+    return log.latest?.hash || null;
+  } catch {
+    return null;
+  }
+}
+
 export function installCommand(program) {
   program
     .command('install [skill]')
@@ -131,21 +242,10 @@ async function resolveAndInstall(skillInput, targetDir, projectRoot, options) {
       throw new Error(`Invalid team:// URL format: ${skillInput}. Expected: team://<registry>/<skill>`);
     }
     
-    // Load registry config
-    const configPath = path.join(JOYSKILL_CONFIG_DIR, 'config.json');
-    if (!fs.existsSync(configPath)) {
-      throw new Error(`No registries configured. Run: joySkills team add <name> <git-url>`);
-    }
-    
-    const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
-    const registries = config.registries || {};
-    const reg = registries[registryName];
+    // Get registry path with auto-prompt for missing registries
+    const registryPath = await getRegistryPathWithPrompt(registryName, options);
     
-    if (!reg?.path || !fs.existsSync(reg.path)) {
-      throw new Error(`Registry "${registryName}" not found. Run: joySkills team list`);
-    }
-    
-    const hit = await tryInstallFromRegistryDir(skillName, reg.path, targetDir, projectRoot, options, `team:${registryName}`);
+    const hit = await tryInstallFromRegistryDir(skillName, registryPath, targetDir, projectRoot, options, `team:${registryName}`);
     if (!hit) {
       throw new Error(`Skill "${skillName}" not found in registry "${registryName}"`);
     }
@@ -202,16 +302,19 @@ async function resolveAndInstall(skillInput, targetDir, projectRoot, options) {
   
   const skillMdPath = path.join(skillPath, 'SKILL.md');
   fs.writeFileSync(skillMdPath, generateSkillTemplate(skillInput));
-  
-  const lockfileManager = new LockfileManager(projectRoot);
-  await lockfileManager.load();
-  lockfileManager.updateSkill(skillInput, { 
-    version: '1.0.0', 
-    source: 'template', 
-    path: skillPath,
-    installedAt: new Date().toISOString() 
-  });
-  await lockfileManager.save();
+
+  // Update lockfile only for project-level installation (npm-like behavior)
+  if (!options.global) {
+    const lockfileManager = new LockfileManager(projectRoot);
+    await lockfileManager.load();
+    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} in ${targetDir}`));
 }
 
@@ -252,16 +355,23 @@ async function tryInstallFromRegistryDir(skillName, registryDirPath, targetDir,
       const installInfo = fs.lstatSync(targetPath);
       const installMethod = installInfo.isSymbolicLink() ? 'symlink' : 'copy';
 
-      const lockfileManager = new LockfileManager(projectRoot);
-      await lockfileManager.load();
-      lockfileManager.updateSkill(skillName, {
-        version,
-        source: sourceLabel,
-        registry: registryManager.getRegistryInfo().registryId,
-        installMethod,
-        installedAt: new Date().toISOString()
-      });
-      await lockfileManager.save();
+      // Get git commit for the skill source
+      const commitHash = await getGitCommit(sourcePath);
+      
+      // Update lockfile only for project-level installation (npm-like behavior)
+      if (!options.global) {
+        const lockfileManager = new LockfileManager(projectRoot);
+        await lockfileManager.load();
+        lockfileManager.updateSkill(skillName, {
+          version,
+          source: sourceLabel,
+          registry: registryManager.getRegistryInfo().registryId,
+          installMethod,
+          commit: commitHash,
+          installedAt: new Date().toISOString()
+        });
+        await lockfileManager.save();
+      }
 
       const methodLabel = installMethod === 'symlink' ? chalk.gray('(symlink)') : chalk.gray('(copy)');
       console.log(chalk.green(`✅ Installed ${skillName} v${version} from ${sourceLabel}`) + ' ' + methodLabel);
@@ -279,14 +389,21 @@ async function tryInstallFromRegistryDir(skillName, registryDirPath, targetDir,
     const targetPath = path.join(targetDir, skillName);
     copyRecursive(skill.path, targetPath);
 
-    const lockfileManager = new LockfileManager(projectRoot);
-    await lockfileManager.load();
-    lockfileManager.updateSkill(skillName, {
-      version: skill.version || '1.0.0',
-      source: sourceLabel,
-      installedAt: new Date().toISOString()
-    });
-    await lockfileManager.save();
+    // Get git commit for the skill source
+    const commitHash = await getGitCommit(skill.path);
+
+    // Update lockfile only for project-level installation (npm-like behavior)
+    if (!options.global) {
+      const lockfileManager = new LockfileManager(projectRoot);
+      await lockfileManager.load();
+      lockfileManager.updateSkill(skillName, {
+        version: skill.version || '1.0.0',
+        source: sourceLabel,
+        commit: commitHash,
+        installedAt: new Date().toISOString()
+      });
+      await lockfileManager.save();
+    }
 
     console.log(chalk.green(`✅ Installed ${skillName} v${skill.version || '1.0.0'} from ${sourceLabel}`));
     return true;
@@ -353,15 +470,18 @@ async function installFromLocalPath(localPath, targetDir, options) {
       const versionMatch = content.match(/version:\s*(.+)/);
       const version = versionMatch?.[1]?.trim() || '1.0.0';
 
-      const lockfileManager = new LockfileManager(process.cwd());
-      await lockfileManager.load();
-      lockfileManager.updateSkill(skillName, {
-        version,
-        source: 'local',
-        path: absPath,
-        installedAt: new Date().toISOString()
-      });
-      await lockfileManager.save();
+      // Update lockfile only for project-level installation (npm-like behavior)
+      if (!options.global) {
+        const lockfileManager = new LockfileManager(process.cwd());
+        await lockfileManager.load();
+        lockfileManager.updateSkill(skillName, {
+          version,
+          source: 'local',
+          path: absPath,
+          installedAt: new Date().toISOString()
+        });
+        await lockfileManager.save();
+      }
 
       console.log(chalk.green(`✅ Installed ${skillName} v${version} from local path`));
     } else {
@@ -389,20 +509,23 @@ async function installFromLocalPath(localPath, targetDir, options) {
         });
       }
 
-      const lockfileManager = new LockfileManager(process.cwd());
-      await lockfileManager.load();
+      // Update lockfile only for project-level installation (npm-like behavior)
+      const lockfileManager = options.global ? null : new LockfileManager(process.cwd());
+      if (lockfileManager) await lockfileManager.load();
 
       for (const skill of selectedSkills) {
         await installSkillFiles(skill, targetDir);
-        lockfileManager.updateSkill(skill.name, {
-          version: skill.version || '1.0.0',
-          source: 'local',
-          path: skill.path,
-          installedAt: new Date().toISOString()
-        });
+        if (lockfileManager) {
+          lockfileManager.updateSkill(skill.name, {
+            version: skill.version || '1.0.0',
+            source: 'local',
+            path: skill.path,
+            installedAt: new Date().toISOString()
+          });
+        }
       }
 
-      await lockfileManager.save();
+      if (lockfileManager) await lockfileManager.save();
       console.log(chalk.green(`\n✅ Installed ${selectedSkills.length} skill(s)`));
     }
   } else {
@@ -475,17 +598,20 @@ async function installFromGitUrl(gitUrl, targetDir, options, subPath = '') {
     await installSkillFiles(skill, targetDir);
   }
 
-  const lockfileManager = new LockfileManager(process.cwd());
-  await lockfileManager.load();
-  for (const skill of selectedSkills) {
-    lockfileManager.updateSkill(skill.name, {
-      version: skill.version || '1.0.0',
-      source: 'git',
-      repository: gitUrl,
-      installedAt: new Date().toISOString()
-    });
+  // Update lockfile only for project-level installation (npm-like behavior)
+  if (!options.global) {
+    const lockfileManager = new LockfileManager(process.cwd());
+    await lockfileManager.load();
+    for (const skill of selectedSkills) {
+      lockfileManager.updateSkill(skill.name, {
+        version: skill.version || '1.0.0',
+        source: 'git',
+        repository: gitUrl,
+        installedAt: new Date().toISOString()
+      });
+    }
+    await lockfileManager.save();
   }
-  await lockfileManager.save();
 
   console.log(chalk.green(`\n✅ Successfully installed ${selectedSkills.length} skill(s)`));
 }
@@ -566,18 +692,20 @@ async function installFromGitHub(owner, repo, skillPath, targetDir, options) {
     await installSkillFiles(skill, targetDir);
   }
   
-  // Update lockfile
-  const lockfileManager = new LockfileManager(process.cwd());
-  await lockfileManager.load();
-  for (const skill of selectedSkills) {
-    lockfileManager.updateSkill(skill.name, {
-      version: skill.version || '1.0.0',
-      source: 'github',
-      repository: `${owner}/${repo}`,
-      installedAt: new Date().toISOString()
-    });
+  // Update lockfile only for project-level installation (npm-like behavior)
+  if (!options.global) {
+    const lockfileManager = new LockfileManager(process.cwd());
+    await lockfileManager.load();
+    for (const skill of selectedSkills) {
+      lockfileManager.updateSkill(skill.name, {
+        version: skill.version || '1.0.0',
+        source: 'github',
+        repository: `${owner}/${repo}`,
+        installedAt: new Date().toISOString()
+      });
+    }
+    await lockfileManager.save();
   }
-  await lockfileManager.save();
   
   console.log(chalk.green(`\n✅ Successfully installed ${selectedSkills.length} skill(s)`));
 }
@@ -623,16 +751,19 @@ async function installFromRegistry(skillName, targetDir, projectRoot, options) {
       const sourcePath = path.join(registryPath, skill.location || skillName);
       if (fs.existsSync(sourcePath)) {
         copyRecursive(sourcePath, skillTargetPath);
-        
-        await lockfileManager.load();
-        lockfileManager.updateSkill(skillName, {
-          version,
-          source: 'registry',
-          registry: registryManager.getRegistryInfo().registryId,
-          installedAt: new Date().toISOString()
-        });
-        await lockfileManager.save();
-        
+
+        // Update lockfile only for project-level installation (npm-like behavior)
+        if (!options.global) {
+          await lockfileManager.load();
+          lockfileManager.updateSkill(skillName, {
+            version,
+            source: 'registry',
+            registry: registryManager.getRegistryInfo().registryId,
+            installedAt: new Date().toISOString()
+          });
+          await lockfileManager.save();
+        }
+
         console.log(chalk.green(`✅ Installed ${skillName} v${version} from registry`));
         return;
       }
@@ -643,14 +774,17 @@ async function installFromRegistry(skillName, targetDir, projectRoot, options) {
   console.log(chalk.yellow(`⚠️  Skill not found in registry, creating template...`));
   const templateContent = generateSkillTemplate(skillName);
   localManager.installSkill(skillName, templateContent);
-  
-  await lockfileManager.load();
-  lockfileManager.updateSkill(skillName, {
-    version: '1.0.0',
-    source: 'template',
-    installedAt: new Date().toISOString()
-  });
-  await lockfileManager.save();
+
+  // Update lockfile only for project-level installation (npm-like behavior)
+  if (!options.global) {
+    await lockfileManager.load();
+    lockfileManager.updateSkill(skillName, {
+      version: '1.0.0',
+      source: 'template',
+      installedAt: new Date().toISOString()
+    });
+    await lockfileManager.save();
+  }
   
   console.log(chalk.green(`✅ Created template for ${skillName}`));
 }
@@ -679,6 +813,15 @@ async function installFromLockfile(targetDir, projectRoot) {
     } else if (skillInfo.source === 'github' && skillInfo.repository) {
       const [owner, repo] = skillInfo.repository.split('/');
       await installFromGitHub(owner, repo, skillName, targetDir, {});
+    } else if (skillInfo.source?.startsWith('team:')) {
+      // Re-install from team registry with auto-prompt
+      const registryName = skillInfo.source.replace('team:', '');
+      const registryPath = await getRegistryPathWithPrompt(registryName, {});
+      const hit = await tryInstallFromRegistryDir(skillName, registryPath, targetDir, projectRoot, {}, skillInfo.source);
+      if (!hit) {
+        console.log(chalk.yellow(`   ⚠️ Skill "${skillName}" not found in registry "${registryName}", trying resolve chain...`));
+        await resolveAndInstall(skillName, targetDir, projectRoot, {});
+      }
     } else {
       // Try full resolve chain
       await resolveAndInstall(skillName, targetDir, projectRoot, {});

package/src/commands/sync.js

@@ -68,12 +68,28 @@ export function syncCommand(program) {
           await lockfileManager.load();
           for (const skill of allSkills) {
             const existing = lockfileManager.getSkill(skill.name);
-            lockfileManager.updateSkill(skill.name, {
+            
+            // Merge existing data with updates, preserving all original fields
+            const updatedEntry = {
+              ...existing,  // Keep all existing fields (registry, commit, etc.)
               version: skill.version || existing?.version || '1.0.0',
-              source: existing?.source || 'local',
-              installedAt: existing?.installedAt || new Date().toISOString(),
-              path: skill.path
-            });
+              path: skill.path,  // Update path (may change if skill moved)
+            };
+            
+            // Set source if not exists
+            if (!updatedEntry.source) {
+              updatedEntry.source = 'local';
+            }
+            
+            // Set installedAt if not exists
+            if (!updatedEntry.installedAt) {
+              updatedEntry.installedAt = new Date().toISOString();
+            }
+            
+            // Add syncedAt timestamp
+            updatedEntry.syncedAt = new Date().toISOString();
+            
+            lockfileManager.updateSkill(skill.name, updatedEntry);
           }
           await lockfileManager.save();
           console.log(chalk.green(`   ✓ Updated joySkills.lock`));

package/src/commands/update.js

@@ -19,6 +19,8 @@ export function updateCommand(program) {
     .description('Update installed skills to latest versions')
     .option('-y, --yes', 'Skip confirmation prompts')
     .option('-a, --all', 'Update all skills')
+    .option('-g, --global', 'Update global (user-level) skills only')
+    .option('-p, --project', 'Update project-level skills only')
     .action(async (skillNames, options) => {
       try {
         const projectRoot = process.cwd();
@@ -31,10 +33,10 @@ export function updateCommand(program) {
         
         if (options.all || skillNames.length === 0) {
           // 更新所有有更新的 skills（Git + team://）
-          skillsToUpdate = await getAllUpdatableSkills(projectRoot);
+          skillsToUpdate = await getAllUpdatableSkills(projectRoot, options.global, options.project);
         } else {
           // 更新指定的 skills
-          skillsToUpdate = await getSpecifiedSkills(projectRoot, skillNames);
+          skillsToUpdate = await getSpecifiedSkills(projectRoot, skillNames, options.global, options.project);
         }
 
         if (skillsToUpdate.length === 0) {
@@ -104,21 +106,39 @@ export function updateCommand(program) {
 
 /**
  * 获取所有可更新的 Skills（Git + team://）
+ * @param {boolean} globalOnly - 只检查全局 skills
+ * @param {boolean} projectOnly - 只检查项目级 skills
  */
-async function getAllUpdatableSkills(projectRoot) {
+async function getAllUpdatableSkills(projectRoot, globalOnly = false, projectOnly = false) {
   const updatable = [];
   
   // 1. 检查 Git 仓库类型的 Skills
-  const gitSkills = await getUpdatableSkills(projectRoot);
+  const gitSkills = await getUpdatableSkills(projectRoot, globalOnly, projectOnly);
   updatable.push(...gitSkills);
   
   // 2. 检查 team:// 类型的 Skills
-  const teamSkills = await getUpdatableTeamSkills(projectRoot);
+  const teamSkills = await getUpdatableTeamSkills(projectRoot, globalOnly, projectOnly);
   updatable.push(...teamSkills);
   
   return updatable;
 }
 
+/**
+ * 获取目录的 git commit hash
+ */
+async function getDirCommit(dirPath) {
+  try {
+    const git = simpleGit(dirPath);
+    const isRepo = await git.checkIsRepo();
+    if (!isRepo) return null;
+    
+    const log = await git.log({ maxCount: 1 });
+    return log.latest?.hash || null;
+  } catch {
+    return null;
+  }
+}
+
 /**
  * 更新 team:// 类型的 Skill
  */
@@ -126,7 +146,10 @@ async function updateTeamSkill(skill, projectRoot) {
   const lockfile = new LockfileManager(projectRoot);
   await lockfile.load();
   
-  const updateInfo = await checkTeamSkillUpdate(skill, skill.source);
+  const lockData = lockfile.getSkill(skill.name);
+  const localCommit = lockData?.commit;
+  
+  const updateInfo = await checkTeamSkillUpdate(skill, skill.source, localCommit);
   
   if (!updateInfo.hasUpdate) {
     throw new Error('No update available');
@@ -140,10 +163,14 @@ async function updateTeamSkill(skill, projectRoot) {
   // 复制新版本
   copyRecursive(updateInfo.registrySkillPath, skill.path);
   
+  // 获取新版本的 commit
+  const newCommit = await getDirCommit(updateInfo.registrySkillPath);
+  
   // 更新 lockfile
   lockfile.updateSkill(skill.name, {
     version: updateInfo.latestVersion,
     source: skill.source,
+    commit: newCommit,
     updatedAt: new Date().toISOString(),
   });
   await lockfile.save();
@@ -173,15 +200,27 @@ function copyRecursive(src, dest) {
 
 /**
  * 获取指定的 Skills
+ * @param {boolean} globalOnly - 只检查全局 skills
+ * @param {boolean} projectOnly - 只检查项目级 skills
  */
-async function getSpecifiedSkills(projectRoot, skillNames) {
+async function getSpecifiedSkills(projectRoot, skillNames, globalOnly = false, projectOnly = false) {
   const skills = [];
   const loader = new SkillLoader(projectRoot);
   const lockfile = new LockfileManager(projectRoot);
   await lockfile.load();
   
+  // 根据选项选择加载方式
+  let allSkills = [];
+  if (globalOnly) {
+    allSkills = loader.loadGlobalSkills();
+  } else if (projectOnly) {
+    allSkills = loader.loadProjectSkills();
+  } else {
+    allSkills = loader.loadAllSkills();
+  }
+  
   for (const name of skillNames) {
-    const skill = loader.getSkill(name);
+    const skill = allSkills.find(s => s.name === name);
     if (!skill) {
       console.log(chalk.red(`❌ Skill not found: ${name}`));
       continue;
@@ -199,7 +238,8 @@ async function getSpecifiedSkills(projectRoot, skillNames) {
     
     if (teamSource) {
       // team:// 类型
-      const updateInfo = await checkTeamSkillUpdate(skill, teamSource);
+      const localCommit = lockData?.commit;
+      const updateInfo = await checkTeamSkillUpdate(skill, teamSource, localCommit);
       if (updateInfo.hasUpdate) {
         skills.push({
           name: skill.name,
@@ -238,7 +278,7 @@ async function getSpecifiedSkills(projectRoot, skillNames) {
 /**
  * 检查 team:// 类型的 Skill 是否有更新
  */
-async function checkTeamSkillUpdate(skill, source) {
+async function checkTeamSkillUpdate(skill, source, localCommit = null) {
   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');
@@ -254,7 +294,7 @@ async function checkTeamSkillUpdate(skill, source) {
     return { hasUpdate: false, error: `Registry ${registryName} not found` };
   }
   
-  // 从 registry 查找最新版本
+  // 从 registry 查找 skill
   const { findSkills } = await import('./install.js');
   const registrySkills = await findSkills(reg.path);
   const registrySkill = registrySkills.find(s => s.name === skill.name);
@@ -263,11 +303,22 @@ async function checkTeamSkillUpdate(skill, source) {
     return { hasUpdate: false, error: 'Skill not found in registry' };
   }
   
-  const hasUpdate = registrySkill.version && registrySkill.version !== skill.version;
+  // 获取 registry 中 skill 的 commit
+  const remoteCommit = await getDirCommit(registrySkill.path);
+  
+  // 使用 commit 对比，如果没有 commit 则 fallback 到 version 对比
+  let hasUpdate = false;
+  if (localCommit && remoteCommit) {
+    hasUpdate = localCommit !== remoteCommit;
+  } else {
+    hasUpdate = registrySkill.version && registrySkill.version !== skill.version;
+  }
   
   return {
     hasUpdate,
     latestVersion: registrySkill.version,
+    localCommit,
+    remoteCommit,
     registryPath: reg.path,
     registrySkillPath: registrySkill.path,
   };
@@ -336,19 +387,29 @@ async function checkGitSkillUpdate(skill) {
 
 /**
  * 获取所有可更新的 team:// Skills
+ * @param {boolean} globalOnly - 只检查全局 skills
+ * @param {boolean} projectOnly - 只检查项目级 skills
  */
-async function getUpdatableTeamSkills(projectRoot) {
+async function getUpdatableTeamSkills(projectRoot, globalOnly = false, projectOnly = false) {
   const updatable = [];
   const loader = new SkillLoader(projectRoot);
   const lockfile = new LockfileManager(projectRoot);
   await lockfile.load();
   
-  const allSkills = loader.loadAllSkills();
+  let allSkills = [];
+  if (globalOnly) {
+    allSkills = loader.loadGlobalSkills();
+  } else if (projectOnly) {
+    allSkills = loader.loadProjectSkills();
+  } else {
+    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);
+      const localCommit = lockData?.commit;
+      const updateInfo = await checkTeamSkillUpdate(skill, lockData.source, localCommit);
       if (updateInfo.hasUpdate) {
         updatable.push({
           name: skill.name,

package/src/skill-loader.js

@@ -129,16 +129,32 @@ export class SkillLoader {
    * 仅加载项目级 Skills
    */
   loadProjectSkills(agentId = null) {
-    const allSkills = this.loadAllSkills(agentId);
-    return allSkills.filter(s => s.scope === 'project');
+    const paths = getAllSkillPaths(this.projectRoot, agentId);
+    const skills = [];
+    
+    for (const { path: dirPath, scope, agent } of paths) {
+      if (scope !== 'project') continue;
+      const dirSkills = this.scanDirectory(dirPath, scope, agent);
+      skills.push(...dirSkills);
+    }
+    
+    return skills;
   }
 
   /**
    * 仅加载用户级 Skills
    */
   loadGlobalSkills(agentId = null) {
-    const allSkills = this.loadAllSkills(agentId);
-    return allSkills.filter(s => s.scope === 'global');
+    const paths = getAllSkillPaths(this.projectRoot, agentId);
+    const skills = [];
+    
+    for (const { path: dirPath, scope, agent } of paths) {
+      if (scope !== 'global') continue;
+      const dirSkills = this.scanDirectory(dirPath, scope, agent);
+      skills.push(...dirSkills);
+    }
+    
+    return skills;
   }
 
   /**

package/src/version-checker.js

@@ -80,8 +80,9 @@ export async function checkRemoteUpdate(skillPath, currentCommit) {
  * 检查单个 Skill
  */
 export async function checkSkill(skill, projectRoot) {
-  // 首先尝试从 lockfile 获取 source
+  // 首先尝试从 lockfile 获取 source 和 commit
   let teamSource = null;
+  let localCommit = null;
   
   if (projectRoot) {
     const lockfile = new LockfileManager(projectRoot);
@@ -89,6 +90,7 @@ export async function checkSkill(skill, projectRoot) {
     const lockData = lockfile.getSkill(skill.name);
     if (lockData?.source?.startsWith('team:')) {
       teamSource = lockData.source;
+      localCommit = lockData.commit;
     }
   }
   
@@ -97,9 +99,9 @@ export async function checkSkill(skill, projectRoot) {
     teamSource = await findSkillInRegistries(skill.name);
   }
   
-  // 如果是 team:// skill，对比 registry 版本
+  // 如果是 team:// skill，对比 registry commit
   if (teamSource) {
-    return await checkTeamSkill(skill, teamSource);
+    return await checkTeamSkill(skill, teamSource, localCommit);
   }
   
   // Git skill: 对比 commit
@@ -157,10 +159,26 @@ async function findSkillInRegistries(skillName) {
   return null;
 }
 
+/**
+ * 获取目录的 git commit hash
+ */
+async function getDirCommit(dirPath) {
+  try {
+    const git = simpleGit(dirPath);
+    const isRepo = await git.checkIsRepo();
+    if (!isRepo) return null;
+    
+    const log = await git.log({ maxCount: 1 });
+    return log.latest?.hash || null;
+  } catch {
+    return null;
+  }
+}
+
 /**
  * 检查 team:// skill 更新
  */
-async function checkTeamSkill(skill, source) {
+async function checkTeamSkill(skill, source, localCommit) {
   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');
@@ -188,7 +206,7 @@ async function checkTeamSkill(skill, source) {
     };
   }
   
-  // 从 registry 查找最新版本
+  // 从 registry 查找 skill
   const { findSkills } = await import('./commands/install.js');
   const registrySkills = await findSkills(reg.path);
   const registrySkill = registrySkills.find(s => s.name === skill.name);
@@ -203,24 +221,44 @@ async function checkTeamSkill(skill, source) {
     };
   }
   
-  const hasUpdate = registrySkill.version && registrySkill.version !== skill.version;
+  // 获取 registry 中 skill 的最新 commit
+  const remoteCommit = await getDirCommit(registrySkill.path);
+  
+  // 如果没有 localCommit（旧版本安装的），使用 version 对比作为 fallback
+  let hasUpdate = false;
+  if (localCommit && remoteCommit) {
+    hasUpdate = localCommit !== remoteCommit;
+  } else {
+    hasUpdate = registrySkill.version && registrySkill.version !== skill.version;
+  }
   
   return {
     name: skill.name,
     hasUpdate,
     currentVersion: skill.version,
-    latestVersion: registrySkill.version,
-    commitsBehind: hasUpdate ? 1 : 0,  // 版本不同即视为有更新
+    localCommit: typeof localCommit === 'string' ? localCommit.slice(0, 7) : 'unknown',
+    remoteCommit: typeof remoteCommit === 'string' ? remoteCommit.slice(0, 7) : 'unknown',
+    commitsBehind: hasUpdate ? 1 : 0,
     source: `team:${registryName}`,
   };
 }
 
 /**
  * 检查所有 Skills
+ * @param {boolean} globalOnly - 只检查全局 skills
+ * @param {boolean} projectOnly - 只检查项目级 skills
  */
-export async function checkAllSkills(projectRoot) {
+export async function checkAllSkills(projectRoot, globalOnly = false, projectOnly = false) {
   const loader = new SkillLoader(projectRoot);
-  const skills = loader.loadAllSkills();
+  let skills = [];
+  
+  if (globalOnly) {
+    skills = loader.loadGlobalSkills();
+  } else if (projectOnly) {
+    skills = loader.loadProjectSkills();
+  } else {
+    skills = loader.loadAllSkills();
+  }
   
   const results = [];
   
@@ -234,8 +272,10 @@ export async function checkAllSkills(projectRoot) {
 
 /**
  * 获取可更新的 Skills
+ * @param {boolean} globalOnly - 只检查全局 skills
+ * @param {boolean} projectOnly - 只检查项目级 skills
  */
-export async function getUpdatableSkills(projectRoot) {
-  const results = await checkAllSkills(projectRoot);
+export async function getUpdatableSkills(projectRoot, globalOnly = false, projectOnly = false) {
+  const results = await checkAllSkills(projectRoot, globalOnly, projectOnly);
   return results.filter(r => r.hasUpdate);
 }