eskill 1.0.21 → 1.0.25

package/cli.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { Command } from 'commander';
 import ora from 'ora';
-import { installFromGitUrl, listSkills, removeSkill, cleanupAllSkills, cleanupAll } from './lib/installer.js';
+import { installFromGitUrl, listSkills, removeSkill, cleanupAllSkills, cleanupAll, updateSkill, updateAllSkills } from './lib/installer.js';
 import { AGENTS, getDefaultAgent } from './lib/agent-config.js';
 import { bashCompletionScript, zshCompletionScript, listSkillsForCompletion } from './lib/completion.js';
 import { searchSkills, formatSkillList } from './lib/search.js';
@@ -13,7 +13,7 @@ const program = new Command();
 program
   .name('eskill')
   .description('Unified AI Agent Skills Management - Install skills from Git URLs')
-  .version('1.0.11');
+  .version('1.0.25');
 
 // 安装命令
 program
@@ -59,7 +59,13 @@ program
       console.log(`\n已安装的技能:\n`);
       skills.forEach(skill => {
         const displayName = skill.author ? `${skill.name}@${skill.author}` : skill.name;
-        console.log(`  • ${displayName}`);
+        const versionInfo = skill.version || (skill.commitHash ? `#${skill.commitHash.substring(0, 7)}` : '');
+        const localMark = !skill.gitUrl ? ' [本地]' : '';
+
+        console.log(`  • ${displayName}${localMark}`);
+        if (versionInfo) {
+          console.log(`    版本: ${versionInfo}`);
+        }
       });
       console.log(`\n总计: ${skills.length} 个技能\n`);
     } catch (error) {
@@ -85,6 +91,38 @@ program
     }
   });
 
+// 更新命令
+program
+  .command('update')
+  .description('更新技能')
+  .argument('[name]', '技能名称（不指定则更新所有）')
+  .option('-f, --force', '强制更新（即使版本相同）', false)
+  .action(async (name, options) => {
+    try {
+      if (name) {
+        // 更新单个技能
+        console.log(`\n检查技能: ${name}`);
+        const result = await updateSkill(name, options);
+
+        if (result.local) {
+          console.log('\n⚠️  本地技能无法自动更新，请手动更新\n');
+        } else if (result.updated === false) {
+          console.log(`\n✓ 已是最新版本 (${result.currentVersion})\n`);
+        } else if (result.updated) {
+          console.log(`\n✓ 更新成功:`);
+          console.log(`  旧版本: ${result.currentVersion}`);
+          console.log(`  新版本: ${result.newVersion}\n`);
+        }
+      } else {
+        // 更新所有技能
+        await updateAllSkills(options);
+      }
+    } catch (error) {
+      console.error(`\n❌ 更新失败: ${error.message}\n`);
+      process.exit(1);
+    }
+  });
+
 // 搜索命令
 program
   .command('search')
@@ -122,9 +160,9 @@ program
       }
 
       // 从 API 返回的数据结构中提取技能和分页信息
-      const skills = result.data?.skills || result.data || result.skills || result.results || [];
-      const pagination = result.data?.pagination || result.pagination || {};
-      const total = pagination.total || result.total || skills.length;
+      let skills = result.data?.skills || result.data || result.skills || result.results || [];
+      let pagination = result.data?.pagination || result.pagination || {};
+      let total = pagination.total || result.total || skills.length;
 
       // 确保 skills 是数组
       if (!Array.isArray(skills)) {
@@ -133,6 +171,43 @@ program
         process.exit(1);
       }
 
+      // 智能搜索：如果没有结果且是 name@author 格式
+      if (skills.length === 0) {
+        const match = query.match(/^([^@]+)@([^@]+)$/);
+        if (match) {
+          const [, skillName, author] = match;
+          console.log(`\n💡 未找到 "${query}"，尝试按技能名 "${skillName}" 和作者 "${author}" 搜索...\n`);
+
+          // 重新搜索技能名
+          const newResult = await searchSkills(skillName, {
+            page: 1,
+            limit: 100,
+            sortBy: options.sort,
+            ai: options.ai
+          });
+
+          const allSkills = newResult.data?.skills || newResult.data || newResult.skills || newResult.results || [];
+
+          // 筛选匹配作者的技能（不区分大小写）
+          skills = allSkills.filter(skill => {
+            const skillAuthor = (skill.author || skill.owner || '').toLowerCase();
+            return skillAuthor === author.toLowerCase();
+          });
+
+          total = skills.length;
+
+          if (skills.length > 0) {
+            console.log(`✓ 找到 ${total} 个匹配的技能\n`);
+          } else {
+            console.log(`❌ 仍然未找到匹配的技能\n`);
+            console.log('提示:');
+            console.log(`  - 尝试只搜索技能名: eskill search ${skillName}`);
+            console.log(`  - 尝试只搜索作者: eskill search ${author}\n`);
+            process.exit(0);
+          }
+        }
+      }
+
       console.log(formatSkillList(skills));
 
       // 显示分页信息和提示

package/lib/installer.js

@@ -8,6 +8,45 @@ import { AGENTS, expandHomePath } from './agent-config.js';
 import { searchSkills, formatSkillList } from './search.js';
 import readline from 'readline';
 
+/**
+ * 获取 Git 仓库的当前 commit hash
+ */
+function getGitCommitHash(repoPath) {
+  try {
+    return execSync('git rev-parse HEAD', { cwd: repoPath, encoding: 'utf-8' }).trim();
+  } catch (error) {
+    return null;
+  }
+}
+
+/**
+ * 获取 Git 仓库的当前版本（tag 或 branch）
+ */
+function getGitVersion(repoPath) {
+  try {
+    // 尝试获取最新的 tag
+    const tag = execSync('git describe --tags --abbrev=0 2>/dev/null || echo ""', {
+      cwd: repoPath,
+      encoding: 'utf-8',
+      shell: '/bin/bash'
+    }).trim();
+
+    if (tag) {
+      return tag;
+    }
+
+    // 如果没有 tag，返回 branch
+    const branch = execSync('git rev-parse --abbrev-ref HEAD', {
+      cwd: repoPath,
+      encoding: 'utf-8'
+    }).trim();
+
+    return branch;
+  } catch (error) {
+    return 'unknown';
+  }
+}
+
 /**
  * 获取 eskill 包的安装目录
  * 技能安装在这里，卸载时会自动删除
@@ -79,29 +118,73 @@ function migrateOldSkills() {
 }
 
 /**
- * 保存技能元数据
+ * 读取所有技能元数据
  */
-function saveSkillMeta(skillPath, meta) {
-  const metaPath = join(skillPath, '.eskill-meta.json');
-  writeFileSync(metaPath, JSON.stringify(meta, null, 2));
-}
+function getAllSkillsMeta() {
+  const skillDir = getSkillsStorageDir();
+  const metaPath = join(skillDir, '.eskill-meta.json');
 
-/**
- * 读取技能元数据
- */
-function getSkillMeta(skillPath) {
-  const metaPath = join(skillPath, '.eskill-meta.json');
   if (!existsSync(metaPath)) {
-    return null;
+    return [];
   }
+
   try {
     const content = readFileSync(metaPath, 'utf-8');
     return JSON.parse(content);
   } catch (error) {
-    return null;
+    return [];
   }
 }
 
+/**
+ * 保存所有技能元数据
+ */
+function saveAllSkillsMeta(metaArray) {
+  const skillDir = getSkillsStorageDir();
+
+  // 确保目录存在
+  if (!existsSync(skillDir)) {
+    mkdirSync(skillDir, { recursive: true });
+  }
+
+  const metaPath = join(skillDir, '.eskill-meta.json');
+  writeFileSync(metaPath, JSON.stringify(metaArray, null, 2));
+}
+
+/**
+ * 保存单个技能元数据
+ */
+function saveSkillMeta(skillName, meta) {
+  const allMeta = getAllSkillsMeta();
+
+  // 查找并更新或添加
+  const index = allMeta.findIndex(m => m.name === skillName);
+  if (index >= 0) {
+    allMeta[index] = { ...allMeta[index], ...meta };
+  } else {
+    allMeta.push(meta);
+  }
+
+  saveAllSkillsMeta(allMeta);
+}
+
+/**
+ * 读取单个技能元数据
+ */
+function getSkillMeta(skillName) {
+  const allMeta = getAllSkillsMeta();
+  return allMeta.find(m => m.name === skillName) || null;
+}
+
+/**
+ * 删除技能元数据
+ */
+function removeSkillMeta(skillName) {
+  const allMeta = getAllSkillsMeta();
+  const newMeta = allMeta.filter(m => m.name !== skillName);
+  saveAllSkillsMeta(newMeta);
+}
+
 /**
  * 检测并处理 name@author 格式
  * 返回解析后的 GitHub URL，如果不是该格式则返回原 URL
@@ -117,7 +200,7 @@ async function handleSkillAtAuthorFormat(input) {
 
   const [, skillName, author] = match;
   console.log(`\n检测到技能名称格式: ${skillName}@${author}`);
-  console.log(`正在搜索 "${skillName}"...\n`);
+  console.log(`正在搜索 "${skillName}" 和作者 "${author}"...\n`);
 
   try {
     // 搜索技能
@@ -129,17 +212,28 @@ async function handleSkillAtAuthorFormat(input) {
 
     const skills = result.data?.skills || result.data || result.skills || result.results || [];
 
-    // 筛选出匹配作者的技能
+    // 筛选出匹配作者的技能（不区分大小写）
     const matchedSkills = skills.filter(skill => {
-      const skillAuthor = skill.author || skill.owner || '';
-      return skillAuthor.toLowerCase() === author.toLowerCase();
+      const skillAuthor = (skill.author || skill.owner || '').toLowerCase();
+      return skillAuthor === author.toLowerCase();
     });
 
     if (matchedSkills.length === 0) {
       // 没有找到匹配的作者
       console.log(`❌ 未找到作者 "${author}" 的技能 "${skillName}"\n`);
-      console.log('搜索结果如下:\n');
-      console.log(formatSkillList(skills));
+
+      // 显示找到的同名技能（如果有）
+      if (skills.length > 0) {
+        console.log(`找到 ${skills.length} 个名为 "${skillName}" 的技能，但作者不匹配:\n`);
+        console.log(formatSkillList(skills));
+      }
+
+      // 给出建议
+      console.log(`💡 建议:`);
+      console.log(`  - 尝试搜索其他作者: eskill search ${skillName}`);
+      console.log(`  - 尝试搜索该作者的其他技能: eskill search ${author}`);
+      console.log(`  - 或直接使用 GitHub URL 安装\n`);
+
       throw new Error(`未找到匹配的技能`);
     }
 
@@ -151,7 +245,7 @@ async function handleSkillAtAuthorFormat(input) {
       throw new Error('技能信息中没有 GitHub URL');
     }
 
-    console.log(`\n✓ 找到匹配的技能:`);
+    console.log(`✓ 找到匹配的技能:`);
     console.log(`  名称: ${skillName}@${author}`);
     console.log(`  Stars: ⭐ ${matchedSkill.stars || 'N/A'}`);
     console.log(`  GitHub: ${githubUrl}\n`);
@@ -275,15 +369,22 @@ export async function installFromGitUrl(gitUrl, options = {}) {
     console.log(`  存储位置: ~/.eskill/skills/`);
     console.log(`  说明: 技能永久保存，更新 eskill 不会丢失`);
 
-    // 保存技能元数据（作者、Git URL 等）
-    saveSkillMeta(targetPath, {
+    // 获取 git 版本信息
+    const commitHash = getGitCommitHash(sourcePath);
+    const version = getGitVersion(sourcePath);
+
+    // 保存技能元数据（作者、Git URL、版本等）
+    saveSkillMeta(skillName, {
       name: skillName,
       author: parsed.owner,
       gitUrl: gitUrl,
       platform: parsed.platform,
       repo: parsed.repo,
       branch: parsed.branch,
-      installedAt: new Date().toISOString()
+      commitHash,
+      version,
+      installedAt: new Date().toISOString(),
+      updatedAt: new Date().toISOString()
     });
 
     return { success: true, path: targetPath };
@@ -310,18 +411,25 @@ export function listSkills(agent = 'claude') {
   }
 
   // 读取目录中的技能
-  return readdirSync(skillDir, { withFileTypes: true })
-    .filter(dirent => dirent.isDirectory())
-    .map(dirent => {
-      const skillPath = join(skillDir, dirent.name);
-      const meta = getSkillMeta(skillPath);
-      return {
-        name: dirent.name,
-        path: skillPath,
-        author: meta?.author || null,
-        installedAt: meta?.installedAt || null
-      };
-    });
+  const skillDirs = readdirSync(skillDir, { withFileTypes: true })
+    .filter(dirent => dirent.isDirectory());
+
+  // 读取所有元数据
+  const allMeta = getAllSkillsMeta();
+
+  return skillDirs.map(dirent => {
+    const skillPath = join(skillDir, dirent.name);
+    const meta = allMeta.find(m => m.name === dirent.name);
+    return {
+      name: dirent.name,
+      path: skillPath,
+      author: meta?.author || null,
+      version: meta?.version || null,
+      commitHash: meta?.commitHash || null,
+      installedAt: meta?.installedAt || null,
+      gitUrl: meta?.gitUrl || null
+    };
+  });
 }
 
 /**
@@ -336,6 +444,7 @@ export function removeSkill(skillName, agent = 'claude') {
   }
 
   rmSync(targetPath, { recursive: true, force: true });
+  removeSkillMeta(skillName);
   console.log(`✓ 已删除技能: ${skillName}`);
 }
 
@@ -385,3 +494,194 @@ export function cleanupAll() {
 export function getSkillsDir() {
   return getSkillsStorageDir();
 }
+
+/**
+ * 更新单个技能
+ */
+export async function updateSkill(skillName, options = {}) {
+  const { force = false } = options;
+  const skillDir = getSkillsStorageDir();
+  const targetPath = join(skillDir, skillName);
+
+  // 检查技能是否存在
+  if (!existsSync(targetPath)) {
+    throw new Error(`技能不存在: ${skillName}`);
+  }
+
+  // 读取元数据
+  const meta = getSkillMeta(skillName);
+
+  // 如果没有 gitUrl，说明是本地技能，无法更新
+  if (!meta || !meta.gitUrl) {
+    return { success: false, local: true, skill: skillName };
+  }
+
+  const currentVersion = meta.version || meta.commitHash?.substring(0, 7) || 'unknown';
+
+  // 重新安装技能（使用内部的 installFromGitUrl，但不打印）
+  try {
+    const parsed = parseGitUrl(meta.gitUrl);
+
+    // 确定技能名称
+    const skillNameFromUrl = parsed.path ? basename(parsed.path) : parsed.repo;
+
+    // 创建临时目录
+    const tempDir = join(tmpdir(), `eskill-update-${Date.now()}`);
+
+    try {
+      // 克隆仓库（静默模式）
+      const cloneUrl = parsed.cloneUrl;
+      execSync(
+        `git clone --depth 1 --branch ${parsed.branch} --single-branch "${cloneUrl}" "${tempDir}"`,
+        { stdio: 'inherit' }
+      );
+
+      // 确定源路径
+      const sourcePath = parsed.path ? join(tempDir, parsed.path) : tempDir;
+
+      // 验证源路径存在
+      if (!existsSync(sourcePath)) {
+        throw new Error(`路径不存在: ${sourcePath}`);
+      }
+
+      // 检查 SKILL.md 是否存在
+      const skillManifestPath = join(sourcePath, 'SKILL.md');
+      if (!existsSync(skillManifestPath)) {
+        throw new Error(`无效的技能包：未找到 SKILL.md 文件`);
+      }
+
+      // 获取新版本信息
+      const newCommitHash = getGitCommitHash(sourcePath);
+      const newVersion = getGitVersion(sourcePath);
+      const newVersionDisplay = newVersion || newCommitHash?.substring(0, 7) || 'unknown';
+
+      // 检查是否有更新
+      if (!force && newCommitHash === meta.commitHash) {
+        // 删除临时目录
+        rmSync(tempDir, { recursive: true, force: true });
+        return { success: true, skill: skillName, updated: false, currentVersion };
+      }
+
+      // 删除旧技能
+      rmSync(targetPath, { recursive: true, force: true });
+
+      // 复制新技能
+      if (process.platform === 'win32') {
+        execSync(`xcopy "${sourcePath}" "${targetPath}" /E /I /H /Y`, { stdio: 'inherit' });
+      } else {
+        execSync(`cp -r "${sourcePath}" "${targetPath}"`, { stdio: 'inherit' });
+      }
+
+      // 更新元数据
+      saveSkillMeta(skillName, {
+        ...meta,
+        commitHash: newCommitHash,
+        version: newVersion,
+        updatedAt: new Date().toISOString()
+      });
+
+      return {
+        success: true,
+        skill: skillName,
+        updated: true,
+        currentVersion,
+        newVersion: newVersionDisplay
+      };
+    } finally {
+      // 清理临时目录
+      if (existsSync(tempDir)) {
+        rmSync(tempDir, { recursive: true, force: true });
+      }
+    }
+  } catch (error) {
+    throw new Error(`更新失败: ${error.message}`);
+  }
+}
+
+/**
+ * 更新所有技能
+ */
+export async function updateAllSkills(options = {}) {
+  const { force = false } = options;
+
+  // 自动迁移旧位置的技能
+  migrateOldSkills();
+
+  const skillDir = getSkillsStorageDir();
+
+  if (!existsSync(skillDir)) {
+    console.log('未安装任何技能');
+    return [];
+  }
+
+  // 读取所有技能
+  const skills = readdirSync(skillDir, { withFileTypes: true })
+    .filter(dirent => dirent.isDirectory())
+    .map(dirent => {
+      const skillPath = join(skillDir, dirent.name);
+      const meta = getSkillMeta(dirent.name);
+      return {
+        name: dirent.name,
+        path: skillPath,
+        meta
+      };
+    });
+
+  if (skills.length === 0) {
+    console.log('未安装任何技能');
+    return [];
+  }
+
+  console.log(`\n检查 ${skills.length} 个技能的更新...\n`);
+
+  const results = {
+    updated: [],
+    skipped: [],
+    failed: []
+  };
+
+  for (const skill of skills) {
+    try {
+      // 如果没有 gitUrl，跳过
+      if (!skill.meta || !skill.meta.gitUrl) {
+        console.log(`⊘ ${skill.name} - 本地技能`);
+        results.skipped.push({ name: skill.name, reason: 'local' });
+        continue;
+      }
+
+      // 更新技能
+      const result = await updateSkill(skill.name, { force });
+
+      if (result.success && result.updated) {
+        console.log(`✓ ${skill.name} - ${result.currentVersion} → ${result.newVersion}`);
+        results.updated.push({ name: skill.name, oldVersion: result.currentVersion, newVersion: result.newVersion });
+      } else if (result.success && !result.updated) {
+        console.log(`• ${skill.name} - 已是最新`);
+        results.skipped.push({ name: skill.name, reason: 'latest' });
+      } else if (result.local) {
+        results.skipped.push({ name: skill.name, reason: 'local' });
+      }
+    } catch (error) {
+      console.log(`✗ ${skill.name} - 失败: ${error.message}`);
+      results.failed.push({ name: skill.name, error: error.message });
+    }
+  }
+
+  // 显示总结
+  console.log(`\n${'─'.repeat(50)}`);
+  console.log(`更新完成:`);
+  console.log(`  ✓ 成功: ${results.updated.length}`);
+  console.log(`  ⊘ 跳过: ${results.skipped.length}`);
+  console.log(`  ✗ 失败: ${results.failed.length}`);
+  console.log(`${'─'.repeat(50)}\n`);
+
+  if (results.failed.length > 0) {
+    console.log('失败的技能:');
+    results.failed.forEach(({ name, error }) => {
+      console.log(`  - ${name}: ${error}`);
+    });
+    console.log('');
+  }
+
+  return results;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eskill",
-  "version": "1.0.21",
+  "version": "1.0.25",
   "description": "Unified AI Agent Skills Management - Install skills from Git URLs",
   "main": "index.js",
   "type": "module",