eskill 1.1.0 → 1.2.1

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, updateSkill, updateAllSkills } from './lib/installer.js';
+import { installFromGitUrl, listSkills, removeSkill, linkSkill, 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.1.0')
+  .version('1.2.1')
   .option('-g, --global', '使用全局技能目录（~/.eskill/skills/），否则使用当前目录（./.claude/skills/）', false);
 
 // 安装命令
@@ -67,17 +67,34 @@ program
 
       const location = global ? '~/.eskill/skills/' : './.claude/skills/';
       console.log(`\n已安装的技能 (${location}):\n`);
+
+      // 来源类型显示映射
+      const sourceLabels = {
+        'symlink': '🔗 软链',
+        'copied-from-global': '📋 复制',
+        'github': '📥 GitHub',
+        'local': '👤 本地',
+        'unknown': '❓ 未知'
+      };
+
       skills.forEach(skill => {
         const displayName = skill.author ? `${skill.name}@${skill.author}` : skill.name;
         const versionInfo = skill.version || (skill.commitHash ? `#${skill.commitHash.substring(0, 7)}` : '');
-        const localMark = !skill.gitUrl ? ' [本地]' : '';
+        const sourceLabel = sourceLabels[skill.source] || sourceLabels['unknown'];
 
-        console.log(`  • ${displayName}${localMark}`);
+        console.log(`  • ${displayName} [${sourceLabel}]`);
         if (versionInfo) {
           console.log(`    版本: ${versionInfo}`);
         }
       });
       console.log(`\n总计: ${skills.length} 个技能\n`);
+
+      // 显示来源说明
+      console.log('来源说明:');
+      console.log('  🔗 软链    - 指向全局仓库的软链接');
+      console.log('  📋 复制   - 从全局仓库复制到本地');
+      console.log('  📥 GitHub - 从 GitHub 直接下载');
+      console.log('  👤 本地    - 用户手动创建\n');
     } catch (error) {
       console.error(`错误: ${error.message}`);
       process.exit(1);
@@ -105,6 +122,25 @@ program
     }
   });
 
+// 链接命令
+program
+  .command('link')
+  .description('将全局技能软链接到本地')
+  .argument('<name>', '技能名称（不需要 @作者）')
+  .action(async (name) => {
+    try {
+      const result = await linkSkill(name);
+
+      // 如果用户取消链接，正常退出
+      if (result && result.cancelled) {
+        process.exit(0);
+      }
+    } catch (error) {
+      console.error(`\n❌ 链接失败: ${error.message}`);
+      process.exit(1);
+    }
+  });
+
 // 更新命令
 program
   .command('update')

package/lib/installer.js

@@ -1,5 +1,5 @@
 import { execSync } from 'child_process';
-import { existsSync, mkdirSync, symlinkSync, rmSync, readdirSync, writeFileSync, readFileSync, copyFileSync } from 'fs';
+import { existsSync, mkdirSync, symlinkSync, rmSync, readdirSync, writeFileSync, readFileSync, copyFileSync, lstatSync } from 'fs';
 import { join, basename, dirname } from 'path';
 import { tmpdir, homedir } from 'os';
 import { fileURLToPath } from 'url';
@@ -250,9 +250,25 @@ async function handleSkillAtAuthorFormat(input, global = false) {
       const globalSkillPath = join(globalSkillsDir, skillName);
 
       if (existsSync(globalSkillPath)) {
-        // 全局仓库中找到，直接复制
+        // 全局仓库中找到，检查本地是否已存在
         console.log(`✓ 在全局仓库中找到技能: ${skillName}`);
-        console.log(`  位置: ~/.eskill/skills/${skillName}\n`);
+        console.log(`  位置: ~/.eskill/skills/${skillName}`);
+
+        const localSkillsDir = getSkillsDir(false);
+        const localSkillPath = join(localSkillsDir, skillName);
+
+        if (existsSync(localSkillPath)) {
+          console.log(`\n⚠️  本地已存在同名技能: ${skillName}`);
+          console.log(`  位置: ${localSkillPath}\n`);
+
+          const overwrite = await confirmAction('是否覆盖本地已存在的技能？');
+          if (!overwrite) {
+            console.log('\n已取消安装\n');
+            throw new Error('用户取消安装');
+          }
+        }
+
+        console.log();
 
         // 返回特殊标记，表示需要从全局复制
         return `GLOBAL:${skillName}`;
@@ -284,9 +300,25 @@ async function handleSkillAtAuthorFormat(input, global = false) {
     const globalSkillPath = join(globalSkillsDir, skillName);
 
     if (existsSync(globalSkillPath)) {
-      // 全局仓库中找到，直接复制
+      // 全局仓库中找到，检查本地是否已存在
       console.log(`✓ 在全局仓库中找到技能: ${skillName}`);
-      console.log(`  位置: ~/.eskill/skills/${skillName}\n`);
+      console.log(`  位置: ~/.eskill/skills/${skillName}`);
+
+      const localSkillsDir = getSkillsDir(false);
+      const localSkillPath = join(localSkillsDir, skillName);
+
+      if (existsSync(localSkillPath)) {
+        console.log(`\n⚠️  本地已存在同名技能: ${skillName}`);
+        console.log(`  位置: ${localSkillPath}\n`);
+
+        const overwrite = await confirmAction('是否覆盖本地已存在的技能？');
+        if (!overwrite) {
+          console.log('\n已取消安装\n');
+          throw new Error('用户取消安装');
+        }
+      }
+
+      console.log();
 
       // 返回特殊标记，表示需要从全局复制
       return `GLOBAL:${skillName}`;
@@ -366,6 +398,21 @@ async function copyFromGlobal(skillName, options = {}) {
   const sourcePath = join(globalSkillsDir, skillName);
   const targetPath = join(localSkillsDir, skillName);
 
+  // 检查本地技能目录是否存在
+  if (!existsSync(localSkillsDir)) {
+    console.log(`\n📁 本地技能目录不存在`);
+    console.log(`  需要创建: ${localSkillsDir}\n`);
+
+    const createDir = await confirmAction('是否创建本地技能目录？');
+    if (!createDir) {
+      console.log('\n已取消安装\n');
+      return { success: false, cancelled: true };
+    }
+
+    mkdirSync(localSkillsDir, { recursive: true });
+    console.log(`✓ 已创建目录: ${localSkillsDir}\n`);
+  }
+
   // 检查本地是否已存在同名技能
   if (existsSync(targetPath)) {
     if (!force) {
@@ -389,10 +436,23 @@ async function copyFromGlobal(skillName, options = {}) {
 
   execSync(`cp -r "${sourcePath}" "${targetPath}"`, { stdio: 'inherit' });
 
-  // 复制元数据
+  // 复制元数据，并标记来源
   const globalMeta = getSkillMeta(skillName, true);
   if (globalMeta) {
-    saveSkillMeta(skillName, globalMeta, false);
+    saveSkillMeta(skillName, {
+      ...globalMeta,
+      source: 'copied-from-global',
+      installedAt: new Date().toISOString(),
+      updatedAt: new Date().toISOString()
+    }, false);
+  } else {
+    // 如果全局没有元数据，创建基础元数据
+    saveSkillMeta(skillName, {
+      name: skillName,
+      source: 'copied-from-global',
+      installedAt: new Date().toISOString(),
+      updatedAt: new Date().toISOString()
+    }, false);
   }
 
   console.log(`\n✓ 技能已从全局仓库复制到本地`);
@@ -425,13 +485,21 @@ function confirmAction(message) {
 export async function installFromGitUrl(gitUrl, options = {}) {
   const { agent = 'claude', link = false, force = false, global = false } = options;
 
-  // 检测并处理 name@author 格式
-  let actualUrl = await handleSkillAtAuthorFormat(gitUrl, global);
+  try {
+    // 检测并处理 name@author 格式
+    let actualUrl = await handleSkillAtAuthorFormat(gitUrl, global);
 
-  // 如果是从全局复制
-  if (actualUrl.startsWith('GLOBAL:')) {
-    const skillName = actualUrl.replace('GLOBAL:', '');
-    return await copyFromGlobal(skillName, options);
+    // 如果是从全局复制
+    if (actualUrl.startsWith('GLOBAL:')) {
+      const skillName = actualUrl.replace('GLOBAL:', '');
+      return await copyFromGlobal(skillName, options);
+    }
+  } catch (error) {
+    // 用户取消安装
+    if (error.message === '用户取消安装') {
+      return { success: false, cancelled: true };
+    }
+    throw error;
   }
 
   // 解析 Git URL
@@ -464,9 +532,19 @@ export async function installFromGitUrl(gitUrl, options = {}) {
     console.log(`路径: ${parsed.path}`);
   }
 
-  // 确保技能目录存在
+  // 检查技能目录是否存在
   if (!existsSync(skillsDir)) {
+    console.log(`\n📁 技能目录不存在`);
+    console.log(`  需要创建: ${skillsDir}\n`);
+
+    const createDir = await confirmAction('是否创建技能目录？');
+    if (!createDir) {
+      console.log('\n已取消安装\n');
+      return { success: false, cancelled: true };
+    }
+
     mkdirSync(skillsDir, { recursive: true });
+    console.log(`✓ 已创建目录: ${skillsDir}\n`);
   }
 
   // 检查是否已存在同名技能
@@ -545,6 +623,7 @@ export async function installFromGitUrl(gitUrl, options = {}) {
       branch: parsed.branch,
       commitHash,
       version,
+      source: global ? 'github' : 'github',
       installedAt: new Date().toISOString(),
       updatedAt: new Date().toISOString()
     }, global);
@@ -574,22 +653,71 @@ export function listSkills(agent = 'claude', global = false) {
 
   // 读取目录中的技能
   const skillDirs = readdirSync(skillDir, { withFileTypes: true })
-    .filter(dirent => dirent.isDirectory());
+    .filter(dirent => dirent.isDirectory() || dirent.isSymbolicLink());
 
   // 读取所有元数据
   const allMeta = getAllSkillsMeta(global);
 
+  // 获取全局技能目录（用于检测是否从全局复制）
+  const globalSkillsDir = getSkillsDir(true);
+  const globalSkillsExists = existsSync(globalSkillsDir);
+  const globalSkillNames = globalSkillsExists
+    ? readdirSync(globalSkillsDir, { withFileTypes: true })
+        .filter(dirent => dirent.isDirectory())
+        .map(dirent => dirent.name)
+    : [];
+
   return skillDirs.map(dirent => {
-    const skillPath = join(skillDir, dirent.name);
-    const meta = allMeta.find(m => m.name === dirent.name);
+    const skillName = dirent.name;
+    const skillPath = join(skillDir, skillName);
+    const meta = allMeta.find(m => m.name === skillName);
+
+    // 优先使用元数据中的 source 字段
+    let source = meta?.source || null;
+    let isSymlink = false;
+
+    // 如果元数据中没有 source，则进行检测
+    if (!source) {
+      try {
+        const stat = lstatSync(skillPath);
+        isSymlink = stat.isSymbolicLink();
+
+        if (isSymlink) {
+          source = 'symlink';
+        } else if (meta?.gitUrl) {
+          // 有 gitUrl，判断是否从全局复制
+          if (!global && globalSkillNames.includes(skillName)) {
+            source = 'copied-from-global';
+          } else {
+            source = 'github';
+          }
+        } else {
+          // 没有 gitUrl，是用户自己创建的
+          source = 'local';
+        }
+      } catch (error) {
+        // 检测失败，默认为 local
+        source = 'local';
+      }
+    } else {
+      // 从元数据中读取是否为符号链接
+      try {
+        isSymlink = lstatSync(skillPath).isSymbolicLink();
+      } catch (error) {
+        isSymlink = false;
+      }
+    }
+
     return {
-      name: dirent.name,
+      name: skillName,
       path: skillPath,
       author: meta?.author || null,
       version: meta?.version || null,
       commitHash: meta?.commitHash || null,
       installedAt: meta?.installedAt || null,
-      gitUrl: meta?.gitUrl || null
+      gitUrl: meta?.gitUrl || null,
+      source: source,
+      isSymlink: isSymlink
     };
   });
 }
@@ -610,6 +738,95 @@ export function removeSkill(skillName, agent = 'claude', global = false) {
   console.log(`✓ 已删除技能: ${skillName}`);
 }
 
+/**
+ * 链接全局技能到本地
+ */
+export async function linkSkill(skillName) {
+  const globalSkillsDir = getSkillsDir(true);
+  const localSkillsDir = getSkillsDir(false);
+
+  const globalSkillPath = join(globalSkillsDir, skillName);
+  const localSkillPath = join(localSkillsDir, skillName);
+
+  // 检查全局是否存在该技能
+  if (!existsSync(globalSkillPath)) {
+    console.log(`\n❌ 全局仓库中不存在技能: ${skillName}`);
+    console.log(`   位置: ~/.eskill/skills/${skillName}\n`);
+    console.log(`💡 提示:`);
+    console.log(`   - 使用 "eskill install -g ${skillName}" 先安装到全局仓库`);
+    console.log(`   - 或使用 "eskill install" 直接安装到本地\n`);
+    throw new Error(`全局仓库中不存在技能: ${skillName}`);
+  }
+
+  // 检查本地技能目录是否存在
+  if (!existsSync(localSkillsDir)) {
+    console.log(`\n📁 本地技能目录不存在`);
+    console.log(`  需要创建: ${localSkillsDir}\n`);
+
+    const createDir = await confirmAction('是否创建本地技能目录？');
+    if (!createDir) {
+      console.log('\n已取消链接\n');
+      return { success: false, cancelled: true };
+    }
+
+    mkdirSync(localSkillsDir, { recursive: true });
+    console.log(`✓ 已创建目录: ${localSkillsDir}\n`);
+  }
+
+  // 检查本地是否已存在同名技能
+  if (existsSync(localSkillPath)) {
+    console.log(`\n⚠️  本地已存在同名技能: ${skillName}`);
+    console.log(`  位置: ${localSkillPath}\n`);
+
+    const overwrite = await confirmAction('是否删除本地技能并创建软链接？');
+    if (!overwrite) {
+      console.log('\n已取消链接\n');
+      return { success: false, cancelled: true };
+    }
+
+    console.log(`删除本地已存在的技能: ${localSkillPath}`);
+    rmSync(localSkillPath, { recursive: true, force: true });
+  }
+
+  // 创建软链接
+  console.log(`\n创建软链接:`);
+  console.log(`  源: ${globalSkillPath}`);
+  console.log(`  目标: ${localSkillPath}\n`);
+
+  try {
+    symlinkSync(globalSkillPath, localSkillPath, 'dir');
+
+    console.log(`✓ 软链接创建成功`);
+    console.log(`  技能: ${skillName}`);
+    console.log(`  本地路径: ${localSkillPath}`);
+    console.log(`  全局路径: ${globalSkillPath}`);
+    console.log(`  说明: 本地技能指向全局仓库，全局更新会自动同步\n`);
+
+    // 保存元数据，标记来源为软链接
+    const globalMeta = getSkillMeta(skillName, true);
+    if (globalMeta) {
+      saveSkillMeta(skillName, {
+        ...globalMeta,
+        source: 'symlink',
+        installedAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString()
+      }, false);
+    } else {
+      // 如果全局没有元数据，创建基础元数据
+      saveSkillMeta(skillName, {
+        name: skillName,
+        source: 'symlink',
+        installedAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString()
+      }, false);
+    }
+
+    return { success: true, path: localSkillPath };
+  } catch (error) {
+    throw new Error(`创建软链接失败: ${error.message}`);
+  }
+}
+
 /**
  * 清理所有技能（用于卸载）
  */

package/package.json

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