skill-linker 1.1.0 → 3.0.0

package/README.md

@@ -1,22 +1,23 @@
-# AI Agent Skill Installer
+# AI Agent Skill Installer (skill-linker)
 
-一個互動式 CLI 工具，用於將 AI Agent Skills 快速連結（Symlink）到各種 AI Agent 的專案或全域目錄中。
+一個現代化的互動式 CLI 工具，用於將 AI Agent Skills 快速連結（Symlink）到各種 AI Agent 的專案或全域目錄中。
 
 ## ✨ 功能特色
 
-- **多 Agent 支援**：支援 Claude Code, GitHub Copilot, Antigravity, Cursor, Windsurf, OpenCode 等。
+- **現代化 TUI 介面**：使用 `prompts` 提供流暢的互動體驗。
+- **模糊搜尋 (Fuzzy Search)**：在選擇 Skill 時可輸入關鍵字快速過濾。
+- **智慧偵測**：自動偵測系統中已安裝的 Agent，並在選單中預設勾選。
+- **多 Agent 支援**：支援 Claude Code, GitHub Copilot, Antigravity, Cursor, Windsurf, OpenCode, Gemini CLI 等。
 - **雙重範圍 (Scope)**：可選擇安裝到當前 `專案目錄 (Project)` 或 `全域目錄 (Global)`。
-- **自動 Clone**：使用 `--from` 參數可直接從 GitHub Clone Skill。
-- **Skill Library 支援**：自動偵測統一的 Skill 存放區。
+- **自動 Clone**：支援從 GitHub Clone 並自動處理 Multi-skill Repos。
+- **完全相容 npx**：無需安裝，隨插即用。
 
 ## 🚀 快速開始
 
 ### 方式 1：使用 npx (推薦)
 
-無需安裝，直接執行：
-
 ```bash
-# 互動式選擇本地 Skill
+# 啟動互動式安裝介面
 npx skill-linker
 
 # 從 GitHub Clone 並安裝
@@ -26,63 +27,57 @@ npx skill-linker --from https://github.com/user/my-skill
 npx skill-linker /path/to/my-skill
 ```
 
-### 方式 2：Clone 此專案
+### 方式 2：本地開發/安裝
 
 ```bash
-git clone https://github.com/user/skill-installer.git
-cd skill-installer
-./link-skill.sh
+git clone https://github.com/raybird/skill-linker.git
+cd skill-linker
+npm install
+npm link # 之後可直接使用 skill-linker 指令
 ```
 
 ## 🛠️ 命令說明
 
 ```
-Usage: link-skill.sh [OPTIONS] [SKILL_PATH]
+Usage: skill-linker [options] [command] [skill-path]
 
-Options:
-  --from <github_url>   從 GitHub Clone Skill 後再連結
-  --help                顯示說明
-
-Examples:
-  ./link-skill.sh                           # 互動式選擇
-  ./link-skill.sh /path/to/skill            # 指定本地 Skill
-  ./link-skill.sh --from https://github.com/user/my-skill
-  ./link-skill.sh --from https://github.com/anthropics/skills/tree/main/skills/pdf
-```
+Interactive CLI to link AI Agent Skills to various agents
 
-### Multi-Skill Repo 支援
+Arguments:
+  skill-path           指定本地 Skill 目錄路徑
 
-對於包含多個 Skills 的 Repo（如 `anthropics/skills`），腳本會：
-1. 自動偵測 `skills/` 子目錄
-2. 列出所有可用的 Skills 讓您選擇
-3. 或者您可以直接在 URL 中指定子路徑（如 `/tree/main/skills/pdf`）
+Options:
+  -V, --version        顯示版本號
+  --from <github-url>  從 GitHub Clone Skill 後再連結
+  -l, --list           列出庫中的 Skills (可互動選擇)
+  -h, --help           顯示說明
 
-## 📦 推薦的 Public Skill Repos
+Commands:
+  list                 列出所有庫中的 Repos 與其 Skills
+```
 
-| Repo | 說明 |
-|------|------|
-| [anthropics/skills](https://github.com/anthropics/skills) | Claude 官方 Skills (pdf, docx, pptx, xlsx...) |
-| [obra/superpowers](https://github.com/obra/superpowers) | 開發流程 Skills (TDD, debugging, code-review...) |
+### 📋 瀏覽模式 (List Mode)
 
-```bash
-# 安裝 Anthropic 的 PDF Skill
-npx skill-linker --from https://github.com/anthropics/skills/tree/main/skills/pdf
+使用 `list` 子指令或 `-l` 參數可以啟動兩層式的互動瀏覽：
 
-# 安裝 obra 的所有開發 Skills (可互動選擇)
-npx skill-linker --from https://github.com/obra/superpowers
+```bash
+npx skill-linker list
 ```
 
-## 📂 Skill Library
+1. **第一層**：選擇已 Clone 的 Repository (會標註是否有 `skills/` 子目錄)。
+2. **第二層**：如果該 Repo 包含多個 Skills，會進階列出供您查看。
 
-建議將您的 Public Skills 統一存放在 `~/Documents/AgentSkills`：
+## 📂 Skill Library 管理
 
-```bash
-mkdir -p ~/Documents/AgentSkills
-cd ~/Documents/AgentSkills
-git clone https://github.com/anthropics/skills.git
-```
+當您使用 `--from` 參數時，Skills 會自動存放到 `~/Documents/AgentSkills`，並以 **owner/repo** 結構分層：
 
-腳本會自動偵測此目錄並列出可用的 Skills。
+```
+~/Documents/AgentSkills/
+├── anthropics/
+│   └── skills/          # https://github.com/anthropics/skills
+└── your-org/
+    └── your-skill/      # https://github.com/your-org/your-skill
+```
 
 ## 🛠️ 支援的 Agent 與路徑
 
@@ -97,11 +92,19 @@ git clone https://github.com/anthropics/skills.git
 | **Gemini CLI** | `.gemini/skills/` | `~/.gemini/skills/` |
 | **Windsurf** | `.windsurf/skills/` | `~/.codeium/windsurf/skills/` |
 
+## 📦 推薦的 Public Skill Repos
+
+| Repo | 說明 |
+|------|------|
+| [anthropics/skills](https://github.com/anthropics/skills) | Claude 官方 Skills (pdf, docx, pptx, xlsx...) |
+| [moltbot/skills](https://github.com/moltbot/skills) | 各種封存的 AI Agent Skills (來自 clawdhub.com) |
+
 ## ⚠️ 注意事項
 
-1. **Windows 使用者**：請使用 WSL 或 Git Bash 執行此工具。
-2. **Git Clone First**：`--from` 參數會自動處理 clone，但如果不使用該參數，請確保 Skill 已在本地。
+1. **權限問題**：在建立 Symlink 時，請確保您有對應目錄的寫入權限。
+2. **環境需求**：需安裝 Node.js 14.0.0 以上版本。
 
 ## 授權
 
 MIT License
+

package/bin/cli.js

@@ -1,48 +1,8 @@
 #!/usr/bin/env node
 
 /**
- * skill-linker CLI
- * Node.js wrapper for link-skill.sh
+ * skill-linker CLI entry point
+ * Modern Node.js implementation with interactive TUI
  */
 
-const { spawn } = require('child_process');
-const path = require('path');
-const fs = require('fs');
-
-// Get the path to the shell script
-const scriptPath = path.join(__dirname, '..', 'link-skill.sh');
-
-// Check if bash is available
-const isWindows = process.platform === 'win32';
-
-if (isWindows) {
-    console.error('\x1b[31m[ERROR]\x1b[0m This tool requires Bash.');
-    console.error('On Windows, please use WSL (Windows Subsystem for Linux) or Git Bash.');
-    console.error('');
-    console.error('Example with WSL:');
-    console.error('  wsl npx skill-linker');
-    process.exit(1);
-}
-
-// Check if script exists
-if (!fs.existsSync(scriptPath)) {
-    console.error('\x1b[31m[ERROR]\x1b[0m Shell script not found:', scriptPath);
-    process.exit(1);
-}
-
-// Forward all arguments to the shell script
-const args = process.argv.slice(2);
-
-const child = spawn('bash', [scriptPath, ...args], {
-    stdio: 'inherit',
-    cwd: process.cwd()
-});
-
-child.on('error', (err) => {
-    console.error('\x1b[31m[ERROR]\x1b[0m Failed to run script:', err.message);
-    process.exit(1);
-});
-
-child.on('close', (code) => {
-    process.exit(code || 0);
-});
+require('../src/cli.js');

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "skill-linker",
-  "version": "1.1.0",
+  "version": "3.0.0",
   "description": "Interactive CLI to link AI Agent Skills to various agents (Claude, Copilot, Antigravity, Cursor, etc.)",
   "main": "bin/cli.js",
   "bin": {
-    "skill-linker": "./bin/cli.js"
+    "skill-linker": "bin/cli.js"
   },
   "scripts": {
     "test": "echo \"No tests yet\""
@@ -25,16 +25,22 @@
   ],
   "author": "",
   "license": "MIT",
+  "dependencies": {
+    "chalk": "^4.1.2",
+    "commander": "^12.0.0",
+    "execa": "^5.1.1",
+    "prompts": "^2.4.2"
+  },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/raybird/skill-installer.git"
+    "url": "git+https://github.com/raybird/skill-linker.git"
   },
   "engines": {
     "node": ">=14.0.0"
   },
   "files": [
     "bin/",
-    "link-skill.sh",
+    "src/",
     "README.md"
   ]
-}
+}

package/src/cli.js

@@ -0,0 +1,45 @@
+#!/usr/bin/env node
+
+const { program } = require('commander');
+const chalk = require('chalk');
+const install = require('./commands/install');
+const list = require('./commands/list');
+
+// Package info
+const packageJson = require('../package.json');
+
+program
+    .name('skill-linker')
+    .description('Interactive CLI to link AI Agent Skills to various agents')
+    .version(packageJson.version);
+
+// Default command (install)
+program
+    .argument('[skill-path]', 'Path to skill directory')
+    .option('--from <github-url>', 'Clone skill from GitHub URL first, then link')
+    .option('-l, --list', 'List available skills in library')
+    .action(async (skillPath, options) => {
+        // Handle --list flag
+        if (options.list) {
+            await list();
+            return;
+        }
+
+        // Run install command
+        await install({
+            skill: skillPath,
+            from: options.from
+        });
+    });
+
+// Standalone list command
+program
+    .command('list')
+    .description('List all available skills in the library')
+    .action(async () => {
+        await list();
+    });
+
+// Parse command line arguments
+program.parse(process.argv);
+

package/src/commands/install.js

@@ -0,0 +1,260 @@
+const prompts = require('prompts');
+const chalk = require('chalk');
+const path = require('path');
+const { findSkills, findRepos, dirExists, ensureDir, createSymlink, listDirectories } = require('../utils/file-system');
+const { getAllAgents, detectInstalledAgents } = require('../utils/agents');
+const { DEFAULT_LIB_PATH, cloneOrUpdateRepo, pullRepo } = require('../utils/git');
+
+/**
+ * Main install command
+ * @param {Object} options - Command options
+ */
+async function install(options) {
+    let skillPaths = [];
+
+    // Handle --from flag: Clone from GitHub
+    if (options.from) {
+        console.log(chalk.blue('[INFO]'), `Cloning from ${options.from}...`);
+
+        try {
+            const { skillPath: clonedPath, targetPath, needsUpdate, hasSubpath } = await cloneOrUpdateRepo(options.from);
+
+            if (needsUpdate) {
+                const { shouldUpdate } = await prompts({
+                    type: 'confirm',
+                    name: 'shouldUpdate',
+                    message: `Repository already exists. Update with git pull?`,
+                    initial: false
+                });
+
+                if (shouldUpdate) {
+                    await pullRepo(targetPath);
+                    console.log(chalk.green('[SUCCESS]'), 'Repository updated!');
+                }
+            }
+
+            // If no subpath, check for skills/ subdirectory
+            if (!hasSubpath && dirExists(path.join(targetPath, 'skills'))) {
+                const subSkills = listDirectories(path.join(targetPath, 'skills'));
+
+                if (subSkills.length > 0) {
+                    const { selectedSkills } = await prompts({
+                        type: 'multiselect',
+                        name: 'selectedSkills',
+                        message: 'This repo contains multiple skills. Select skills to install:',
+                        choices: [
+                            ...subSkills.map(s => ({ title: s, value: path.join(targetPath, 'skills', s) })),
+                            { title: 'Link entire repo', value: targetPath }
+                        ],
+                        hint: '- Space to select. Return to submit'
+                    });
+
+                    if (selectedSkills && selectedSkills.length > 0) {
+                        skillPaths = selectedSkills;
+                    } else {
+                        // If nothing selected, maybe they just hit enter without selection? Default to repo path?
+                        // Or better, error out if multiselect returns empty.
+                        // Let's assume empty selection means exit or user made mistake.
+                        // But to be safe, if they chose "Link entire repo" in multiselect (which is weird), handle it.
+                        // Actually multiselect is better for picking subsets.
+                        // If empty, let's fall back to entire repo (or maybe error).
+                        // Let's error to be consistent with agent selection.
+                    }
+                } else {
+                    skillPaths = [targetPath];
+                }
+            } else {
+                skillPaths = [clonedPath];
+            }
+
+            console.log(chalk.green('[SUCCESS]'), 'Clone completed!');
+        } catch (error) {
+            console.error(chalk.red('[ERROR]'), error.message);
+            process.exit(1);
+        }
+    }
+
+    // If no skill path provided, show library selection
+    if (skillPaths.length === 0 && options.skill) {
+        skillPaths = [options.skill];
+    }
+
+    if (skillPaths.length === 0) {
+        if (!dirExists(DEFAULT_LIB_PATH)) {
+            console.error(chalk.red('[ERROR]'), `Skill library not found: ${DEFAULT_LIB_PATH}`);
+            console.log(chalk.blue('[INFO]'), 'Use --from <github_url> to clone skills first.');
+            process.exit(1);
+        }
+
+        const repos = findRepos(DEFAULT_LIB_PATH);
+
+        if (repos.length === 0) {
+            console.error(chalk.red('[ERROR]'), `No repos found in ${DEFAULT_LIB_PATH}`);
+            console.log(chalk.blue('[INFO]'), 'Use --from <github_url> to clone skills first.');
+            process.exit(1);
+        }
+
+        console.log('');
+
+        // 1. Select Repository
+        const { selectedRepo } = await prompts({
+            type: 'autocomplete',
+            name: 'selectedRepo',
+            message: 'Select a repository:',
+            choices: repos.map(repo => ({
+                title: `${repo.name}${repo.hasSkillsDir ? chalk.dim(' (has skills/)') : ''}`,
+                value: repo
+            })),
+            suggest: (input, choices) => {
+                const inputLower = input.toLowerCase();
+                return Promise.resolve(
+                    choices.filter(choice => choice.title.toLowerCase().includes(inputLower))
+                );
+            }
+        });
+
+        if (!selectedRepo) {
+            console.log(chalk.yellow('[WARNING]'), 'No repository selected. Exiting.');
+            process.exit(0);
+        }
+
+        // 2. Select Sub-skills (if applicable)
+        if (selectedRepo.hasSkillsDir) {
+            const skillsDir = path.join(selectedRepo.path, 'skills');
+            const subSkills = listDirectories(skillsDir);
+
+            if (subSkills.length > 0) {
+                const { selectedSubSkills } = await prompts({
+                    type: 'multiselect',
+                    name: 'selectedSubSkills',
+                    message: `Select skills from ${chalk.cyan(selectedRepo.name)} (Space to select):`,
+                    choices: [
+                        ...subSkills.map(s => ({ title: s, value: path.join(skillsDir, s) })),
+                        { title: 'Link entire repo', value: selectedRepo.path }
+                    ],
+                    hint: '- Space to select. Return to submit'
+                });
+
+                if (!selectedSubSkills || selectedSubSkills.length === 0) {
+                    console.log(chalk.yellow('[WARNING]'), 'No skills selected. Exiting.');
+                    process.exit(0);
+                }
+                skillPaths = selectedSubSkills;
+            } else {
+                skillPaths = [selectedRepo.path];
+            }
+        } else {
+            skillPaths = [selectedRepo.path];
+        }
+    }
+
+    // Validate skill paths
+    for (const p of skillPaths) {
+        if (!dirExists(p)) {
+            console.error(chalk.red('[ERROR]'), `Skill directory not found: ${p}`);
+            process.exit(1);
+        }
+    }
+
+    if (skillPaths.length > 1) {
+        console.log(chalk.blue('[INFO]'), `Selected ${skillPaths.length} skills`);
+    } else {
+        const skillName = path.basename(skillPaths[0]);
+        console.log(chalk.blue('[INFO]'), `Selected Skill: ${chalk.cyan(skillName)} (${skillPaths[0]})`);
+    }
+
+    // Agent selection
+    const agents = getAllAgents();
+    const installedIndices = detectInstalledAgents();
+
+    const { selectedAgents } = await prompts({
+        type: 'multiselect',
+        name: 'selectedAgents',
+        message: 'Select agents to install to (Space to select, Enter to confirm):',
+        choices: agents.map((agent, index) => ({
+            title: agent.name + (installedIndices.includes(index) ? chalk.green(' (Installed)') : ''),
+            value: index,
+            selected: installedIndices.includes(index)
+        })),
+        hint: '- Space to select. Return to submit'
+    });
+
+    if (!selectedAgents || selectedAgents.length === 0) {
+        console.log(chalk.yellow('[WARNING]'), 'No agents selected. Exiting.');
+        process.exit(0);
+    }
+
+    // Process each selected agent
+    for (const agentIndex of selectedAgents) {
+        const agent = agents[agentIndex];
+
+        console.log('');
+        console.log(chalk.blue('[INFO]'), `Configuring for ${chalk.cyan(agent.name)}...`);
+
+        const { scope } = await prompts({
+            type: 'select',
+            name: 'scope',
+            message: 'Select scope:',
+            choices: [
+                { title: `Project (${agent.projectDir})`, value: 'project' },
+                { title: `Global (${agent.globalDir})`, value: 'global' },
+                { title: 'Both', value: 'both' },
+                { title: 'Skip', value: 'skip' }
+            ]
+        });
+
+        if (scope === 'skip') continue;
+
+        const targets = [];
+        if (scope === 'project' || scope === 'both') {
+            targets.push(path.join(process.cwd(), agent.projectDir));
+        }
+        if (scope === 'global' || scope === 'both') {
+            targets.push(agent.globalDir);
+        }
+
+        for (const targetBase of targets) {
+            ensureDir(targetBase);
+
+            // Loop through all selected skills and link them
+            for (const sPath of skillPaths) {
+                const sName = path.basename(sPath);
+                const targetLink = path.join(targetBase, sName);
+
+                if (dirExists(targetLink)) {
+                    // Check if already correct link to avoid prompt
+                    // But for simplicity, we prompt or skip. 
+                    // To avoid spamming prompts for multiple skills, maybe auto-overwrite or ask once?
+                    // Let's ask individually for safety for now, or maybe just log and skip if overwrite not confirmed.
+                    // Actually, prompting for every file in a loop is annoying. 
+                    // Let's check overlap first? Or just try createSymlink which handles unlink.
+
+                    // Let's prompt once per agent/target if any conflicts? Too complex.
+                    // Simple approach: Prompt for each conflict.
+                    const { overwrite } = await prompts({
+                        type: 'confirm',
+                        name: 'overwrite',
+                        message: `${targetLink} already exists. Overwrite?`,
+                        initial: false
+                    });
+
+                    if (!overwrite) {
+                        console.log(chalk.blue('[INFO]'), `Skipping ${sName}...`);
+                        continue;
+                    }
+                }
+
+                if (createSymlink(sPath, targetLink)) {
+                    console.log(chalk.green('[SUCCESS]'), `Linked ${sName}`);
+                } else {
+                    console.error(chalk.red('[ERROR]'), `Failed to link ${sName}`);
+                }
+            }
+        }
+    }
+
+    console.log('');
+    console.log(chalk.green('[SUCCESS]'), 'All operations completed.');
+}
+
+module.exports = install;

package/src/commands/list.js

@@ -0,0 +1,78 @@
+const chalk = require('chalk');
+const prompts = require('prompts');
+const path = require('path');
+const { findRepos, listDirectories, dirExists } = require('../utils/file-system');
+const { DEFAULT_LIB_PATH } = require('../utils/git');
+
+/**
+ * List command - shows repos, then skills within selected repo
+ */
+async function list() {
+    if (!dirExists(DEFAULT_LIB_PATH)) {
+        console.error(chalk.red('[ERROR]'), `Skill library not found: ${DEFAULT_LIB_PATH}`);
+        console.log(chalk.blue('[INFO]'), 'Use --from <github_url> to clone skills first.');
+        process.exit(1);
+    }
+
+    const repos = findRepos(DEFAULT_LIB_PATH);
+
+    if (repos.length === 0) {
+        console.log(chalk.yellow('[WARNING]'), `No repos found in ${DEFAULT_LIB_PATH}`);
+        console.log(chalk.blue('[INFO]'), 'Use --from <github_url> to clone skills first.');
+        return;
+    }
+
+    console.log('');
+    console.log(chalk.blue('[INFO]'), `Repositories in library (${DEFAULT_LIB_PATH}):`);
+    console.log('');
+
+    // Show repos with indication if they have skills/ directory
+    const { selectedRepo } = await prompts({
+        type: 'select',
+        name: 'selectedRepo',
+        message: 'Select a repository to view:',
+        choices: repos.map(repo => ({
+            title: `${repo.name}${repo.hasSkillsDir ? chalk.dim(' (has skills/)') : ''}`,
+            value: repo,
+            description: repo.path
+        }))
+    });
+
+    if (!selectedRepo) {
+        console.log(chalk.yellow('[INFO]'), 'No repository selected.');
+        return;
+    }
+
+    console.log('');
+    console.log(chalk.blue('[INFO]'), `Repository: ${chalk.cyan(selectedRepo.name)}`);
+    console.log(chalk.dim(`Path: ${selectedRepo.path}`));
+    console.log('');
+
+    // If repo has skills/ subdirectory, list the skills
+    if (selectedRepo.hasSkillsDir) {
+        const skillsDir = path.join(selectedRepo.path, 'skills');
+        const skills = listDirectories(skillsDir);
+
+        if (skills.length === 0) {
+            console.log(chalk.yellow('[WARNING]'), 'No skills found in skills/ directory');
+            return;
+        }
+
+        console.log(chalk.blue('[INFO]'), 'Skills in this repository:');
+        console.log('');
+
+        skills.forEach((skill, index) => {
+            console.log(`  ${index + 1}. ${chalk.cyan(skill)}`);
+            console.log(`     ${chalk.dim(path.join(skillsDir, skill))}`);
+        });
+
+        console.log('');
+    } else {
+        console.log(chalk.blue('[INFO]'), 'This is a single-skill repository (no skills/ subdirectory)');
+        console.log(chalk.dim('The entire repository acts as one skill'));
+        console.log('');
+    }
+}
+
+module.exports = list;
+

package/src/utils/agents.js

@@ -0,0 +1,91 @@
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+/**
+ * Supported AI Agent configurations
+ * Format: { name, projectDir, globalDir }
+ */
+const AGENTS = [
+    {
+        name: 'Claude Code',
+        projectDir: '.claude/skills',
+        globalDir: path.join(os.homedir(), '.claude/skills')
+    },
+    {
+        name: 'GitHub Copilot',
+        projectDir: '.github/skills',
+        globalDir: path.join(os.homedir(), '.copilot/skills')
+    },
+    {
+        name: 'Google Antigravity',
+        projectDir: '.agent/skills',
+        globalDir: path.join(os.homedir(), '.gemini/antigravity/skills')
+    },
+    {
+        name: 'Cursor',
+        projectDir: '.cursor/skills',
+        globalDir: path.join(os.homedir(), '.cursor/skills')
+    },
+    {
+        name: 'OpenCode',
+        projectDir: '.opencode/skill',
+        globalDir: path.join(os.homedir(), '.config/opencode/skill')
+    },
+    {
+        name: 'OpenAI Codex',
+        projectDir: '.codex/skills',
+        globalDir: path.join(os.homedir(), '.codex/skills')
+    },
+    {
+        name: 'Gemini CLI',
+        projectDir: '.gemini/skills',
+        globalDir: path.join(os.homedir(), '.gemini/skills')
+    },
+    {
+        name: 'Windsurf',
+        projectDir: '.windsurf/skills',
+        globalDir: path.join(os.homedir(), '.codeium/windsurf/skills')
+    }
+];
+
+/**
+ * Detect which agents are installed on the system
+ * @returns {Array} List of detected agent indices
+ */
+function detectInstalledAgents() {
+    const installed = [];
+
+    AGENTS.forEach((agent, index) => {
+        // Check if global directory exists
+        if (fs.existsSync(agent.globalDir)) {
+            installed.push(index);
+        }
+    });
+
+    return installed;
+}
+
+/**
+ * Get agent configuration by index
+ * @param {number} index
+ * @returns {Object} Agent configuration
+ */
+function getAgent(index) {
+    return AGENTS[index];
+}
+
+/**
+ * Get all agents
+ * @returns {Array} All agent configurations
+ */
+function getAllAgents() {
+    return AGENTS;
+}
+
+module.exports = {
+    AGENTS,
+    detectInstalledAgents,
+    getAgent,
+    getAllAgents
+};

package/src/utils/file-system.js

@@ -0,0 +1,166 @@
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Check if a directory exists
+ * @param {string} dirPath
+ * @returns {boolean}
+ */
+function dirExists(dirPath) {
+    try {
+        return fs.existsSync(dirPath) && fs.statSync(dirPath).isDirectory();
+    } catch {
+        return false;
+    }
+}
+
+/**
+ * Ensure directory exists (create if not)
+ * @param {string} dirPath
+ */
+function ensureDir(dirPath) {
+    if (!dirExists(dirPath)) {
+        fs.mkdirSync(dirPath, { recursive: true });
+    }
+}
+
+/**
+ * Create a symbolic link
+ * @param {string} source - Source path
+ * @param {string} target - Target symlink path
+ * @returns {boolean} Success status
+ */
+function createSymlink(source, target) {
+    try {
+        // Remove existing link/file if present
+        if (fs.existsSync(target) || fs.lstatSync(target).isSymbolicLink()) {
+            fs.unlinkSync(target);
+        }
+
+        fs.symlinkSync(source, target, 'dir');
+        return true;
+    } catch (error) {
+        console.error(`Failed to create symlink: ${error.message}`);
+        return false;
+    }
+}
+
+/**
+ * List directories in a path
+ * @param {string} dirPath
+ * @returns {Array<string>} List of directory names
+ */
+function listDirectories(dirPath) {
+    if (!dirExists(dirPath)) {
+        return [];
+    }
+
+    try {
+        return fs.readdirSync(dirPath)
+            .filter(item => {
+                const fullPath = path.join(dirPath, item);
+                return fs.statSync(fullPath).isDirectory();
+            });
+    } catch {
+        return [];
+    }
+}
+
+
+/**
+ * Find all repositories in library
+ * @param {string} libPath - Library root path
+ * @returns {Array<{name: string, path: string, owner: string, repo: string, hasSkillsDir: boolean}>}
+ */
+function findRepos(libPath) {
+    if (!dirExists(libPath)) {
+        return [];
+    }
+
+    const repos = [];
+
+    // Scan owner directories
+    const owners = listDirectories(libPath);
+
+    for (const owner of owners) {
+        const ownerPath = path.join(libPath, owner);
+        const repoList = listDirectories(ownerPath);
+
+        for (const repo of repoList) {
+            const repoPath = path.join(ownerPath, repo);
+            const skillsDir = path.join(repoPath, 'skills');
+
+            repos.push({
+                name: `${owner}/${repo}`,
+                path: repoPath,
+                owner,
+                repo,
+                hasSkillsDir: dirExists(skillsDir)
+            });
+        }
+    }
+
+    return repos;
+}
+
+/**
+ * Find all skill directories in library
+ * @param {string} libPath - Library root path
+ * @returns {Array<{name: string, path: string, owner: string, repo: string}>}
+ */
+function findSkills(libPath) {
+    if (!dirExists(libPath)) {
+        return [];
+    }
+
+    const skills = [];
+
+    // Scan owner directories
+    const owners = listDirectories(libPath);
+
+    for (const owner of owners) {
+        const ownerPath = path.join(libPath, owner);
+        const repos = listDirectories(ownerPath);
+
+        for (const repo of repos) {
+            const repoPath = path.join(ownerPath, repo);
+
+            // Check if this repo has a skills/ subdirectory
+            const skillsDir = path.join(repoPath, 'skills');
+
+            if (dirExists(skillsDir)) {
+                // Multi-skill repo
+                const subSkills = listDirectories(skillsDir);
+
+                for (const skill of subSkills) {
+                    skills.push({
+                        name: `${owner}/${repo}/${skill}`,
+                        path: path.join(skillsDir, skill),
+                        owner,
+                        repo,
+                        skill
+                    });
+                }
+            } else {
+                // Single skill repo
+                skills.push({
+                    name: `${owner}/${repo}`,
+                    path: repoPath,
+                    owner,
+                    repo
+                });
+            }
+        }
+    }
+
+    return skills;
+}
+
+module.exports = {
+    dirExists,
+    ensureDir,
+    createSymlink,
+    listDirectories,
+    findRepos,
+    findSkills
+};

package/src/utils/git.js

@@ -0,0 +1,108 @@
+const execa = require('execa');
+const path = require('path');
+const os = require('os');
+const { dirExists } = require('./file-system');
+
+const DEFAULT_LIB_PATH = path.join(os.homedir(), 'Documents/AgentSkills');
+
+/**
+ * Parse GitHub URL to extract owner, repo, branch, and subpath
+ * @param {string} url - GitHub URL
+ * @returns {Object} Parsed components
+ */
+function parseGitHubUrl(url) {
+    let cleanUrl = url;
+    let subpath = '';
+    let branch = 'main';
+
+    // Check for /tree/branch/path format
+    const treeMatch = url.match(/(.+)\/tree\/([^/]+)\/(.+)$/);
+    if (treeMatch) {
+        cleanUrl = treeMatch[1];
+        branch = treeMatch[2];
+        subpath = treeMatch[3];
+    }
+
+    // Extract owner/repo
+    const repoMatch = cleanUrl.match(/github\.com[/:]([^/]+)\/([^/]+?)(\.git)?$/);
+
+    if (!repoMatch) {
+        throw new Error('Invalid GitHub URL format');
+    }
+
+    return {
+        owner: repoMatch[1],
+        repo: repoMatch[2].replace('.git', ''),
+        branch,
+        subpath,
+        cleanUrl
+    };
+}
+
+/**
+ * Clone a GitHub repository
+ * @param {string} url - GitHub URL
+ * @param {string} targetPath - Target directory
+ * @returns {Promise<void>}
+ */
+async function cloneRepo(url, targetPath) {
+    try {
+        await execa('git', ['clone', url, targetPath]);
+    } catch (error) {
+        throw new Error(`Failed to clone repository: ${error.message}`);
+    }
+}
+
+/**
+ * Pull latest changes in a repository
+ * @param {string} repoPath - Path to repository
+ * @returns {Promise<void>}
+ */
+async function pullRepo(repoPath) {
+    try {
+        await execa('git', ['-C', repoPath, 'pull']);
+    } catch (error) {
+        throw new Error(`Failed to pull repository: ${error.message}`);
+    }
+}
+
+/**
+ * Clone or update a GitHub repository
+ * @param {string} url - GitHub URL
+ * @returns {Promise<{skillPath: string, needsUpdate: boolean}>}
+ */
+async function cloneOrUpdateRepo(url) {
+    const parsed = parseGitHubUrl(url);
+    const targetPath = path.join(DEFAULT_LIB_PATH, parsed.owner, parsed.repo);
+
+    let needsUpdate = false;
+
+    if (dirExists(targetPath)) {
+        // Repo exists, ask if user wants to update
+        needsUpdate = true;
+    } else {
+        // Clone new repo
+        await cloneRepo(parsed.cleanUrl, targetPath);
+    }
+
+    // Determine final skill path
+    let skillPath = targetPath;
+    if (parsed.subpath) {
+        skillPath = path.join(targetPath, parsed.subpath);
+    }
+
+    return {
+        skillPath,
+        targetPath,
+        needsUpdate,
+        hasSubpath: !!parsed.subpath
+    };
+}
+
+module.exports = {
+    DEFAULT_LIB_PATH,
+    parseGitHubUrl,
+    cloneRepo,
+    pullRepo,
+    cloneOrUpdateRepo
+};

package/link-skill.sh

@@ -1,316 +0,0 @@
-#!/bin/bash
-
-# link-skill.sh
-# Interactive script to link AI Agent Skills to various AI agents
-DEFAULT_LIB_PATH="$HOME/Documents/AgentSkills"
-SKILL_PATH=""
-FROM_URL=""
-
-# Helper function for colored output
-print_info() { echo -e "\033[1;34m[INFO]\033[0m $1"; }
-print_success() { echo -e "\033[1;32m[SUCCESS]\033[0m $1"; }
-print_warning() { echo -e "\033[1;33m[WARNING]\033[0m $1"; }
-print_error() { echo -e "\033[1;31m[ERROR]\033[0m $1"; }
-
-# Show help
-show_help() {
-    echo "Usage: link-skill.sh [OPTIONS] [SKILL_PATH]"
-    echo ""
-    echo "Options:"
-    echo "  --from <github_url>   Clone skill from GitHub URL first, then link"
-    echo "  --help                Show this help message"
-    echo ""
-    echo "Examples:"
-    echo "  ./link-skill.sh                           # Interactive selection from library"
-    echo "  ./link-skill.sh /path/to/skill            # Link specific local skill"
-    echo "  ./link-skill.sh --from https://github.com/user/my-skill"
-    echo "  ./link-skill.sh --from https://github.com/anthropics/skills/tree/main/skills/pdf"
-    echo ""
-    echo "Notes:"
-    echo "  - If the cloned repo has a 'skills/' subdirectory, you can pick a specific skill"
-    echo "  - GitHub URLs with /tree/branch/path are supported for direct subpath access"
-    echo ""
-    exit 0
-}
-
-# Parse arguments
-while [[ $# -gt 0 ]]; do
-    case $1 in
-        --from)
-            FROM_URL="$2"
-            shift 2
-            ;;
-        --help|-h)
-            show_help
-            ;;
-        *)
-            SKILL_PATH="$1"
-            shift
-            ;;
-    esac
-done
-
-# 1. Handle --from flag: Clone from GitHub
-if [ -n "$FROM_URL" ]; then
-    # Parse GitHub URL - check for /tree/branch/path format
-    SUBPATH=""
-    CLEAN_URL="$FROM_URL"
-    
-    if [[ "$FROM_URL" =~ (.+)/tree/([^/]+)/(.+)$ ]]; then
-        # URL contains /tree/branch/path - extract subpath
-        BASE_REPO="${BASH_REMATCH[1]}"
-        BRANCH="${BASH_REMATCH[2]}"
-        SUBPATH="${BASH_REMATCH[3]}"
-        CLEAN_URL="$BASE_REPO"
-        print_info "Detected subpath: $SUBPATH (branch: $BRANCH)"
-    fi
-    
-    # Extract repo name from URL
-    REPO_NAME=$(basename "$CLEAN_URL" .git)
-    TARGET_CLONE_PATH="$DEFAULT_LIB_PATH/$REPO_NAME"
-    
-    # Ensure library directory exists
-    mkdir -p "$DEFAULT_LIB_PATH"
-    
-    if [ -d "$TARGET_CLONE_PATH" ]; then
-        print_warning "Directory already exists: $TARGET_CLONE_PATH"
-        read -p "Update with git pull? (y/N): " do_pull
-        if [[ "$do_pull" =~ ^[yY]$ ]]; then
-            print_info "Pulling latest changes..."
-            git -C "$TARGET_CLONE_PATH" pull
-        fi
-    else
-        print_info "Cloning $CLEAN_URL to $TARGET_CLONE_PATH..."
-        git clone "$CLEAN_URL" "$TARGET_CLONE_PATH"
-        if [ $? -ne 0 ]; then
-            print_error "Failed to clone repository"
-            exit 1
-        fi
-        print_success "Clone completed!"
-    fi
-    
-    # If subpath was specified in URL, use it directly
-    if [ -n "$SUBPATH" ]; then
-        SKILL_PATH="$TARGET_CLONE_PATH/$SUBPATH"
-        if [ ! -d "$SKILL_PATH" ]; then
-            print_error "Subpath not found: $SKILL_PATH"
-            exit 1
-        fi
-    else
-        # Check if this is a multi-skill repo (has skills/ subdirectory)
-        SKILLS_DIR="$TARGET_CLONE_PATH/skills"
-        if [ -d "$SKILLS_DIR" ]; then
-            print_info "Detected multi-skill repository. Listing available skills..."
-            
-            sub_skills=("$SKILLS_DIR"/*/)
-            if [ ${#sub_skills[@]} -eq 0 ]; then
-                print_warning "No skills found in $SKILLS_DIR, using repo root"
-                SKILL_PATH="$TARGET_CLONE_PATH"
-            else
-                # Extract skill names for display
-                sub_skill_names=()
-                for s in "${sub_skills[@]}"; do
-                    sub_skill_names+=("$(basename "$s")")
-                done
-                
-                echo ""
-                echo "Available Skills in this repo:"
-                select sub_skill_name in "${sub_skill_names[@]}" "Link entire repo"; do
-                    if [ -n "$sub_skill_name" ]; then
-                        if [ "$sub_skill_name" == "Link entire repo" ]; then
-                            SKILL_PATH="$TARGET_CLONE_PATH"
-                        else
-                            SKILL_PATH="$SKILLS_DIR/$sub_skill_name"
-                        fi
-                        break
-                    else
-                        echo "Invalid selection. Please try again."
-                    fi
-                done
-            fi
-        else
-            SKILL_PATH="$TARGET_CLONE_PATH"
-        fi
-    fi
-fi
-
-# 2. Determine Source Skill Path (if not already set by --from)
-if [ -z "$SKILL_PATH" ]; then
-    # Check if default library exists
-    if [ -d "$DEFAULT_LIB_PATH" ]; then
-        print_info "No skill path provided. Checking default library: $DEFAULT_LIB_PATH"
-        skills=("$DEFAULT_LIB_PATH"/*/)
-        
-        if [ ${#skills[@]} -eq 0 ]; then
-            print_error "No skills found in $DEFAULT_LIB_PATH"
-            print_info "Please provide a skill path: ./link-skill.sh <path_to_skill>"
-            exit 1
-        fi
-
-        # Extract skill names for display
-        skill_names=()
-        for s in "${skills[@]}"; do
-            skill_names+=("$(basename "$s")")
-        done
-
-        echo "Available Skills:"
-        select skill_name in "${skill_names[@]}"; do
-            if [ -n "$skill_name" ]; then
-                SKILL_PATH="${DEFAULT_LIB_PATH}/${skill_name}"
-                break
-            else
-                echo "Invalid selection. Please try again."
-            fi
-        done
-    else
-        # Fallback to current directory prompt
-        read -p "Enter path to skill directory (default: current dir): " input_path
-        input_path=${input_path:-.}
-        SKILL_PATH=$(realpath "$input_path")
-    fi
-elif [ -n "$SKILL_PATH" ] && [ -z "$FROM_URL" ]; then
-    # Path provided directly as argument
-    SKILL_PATH=$(realpath "$SKILL_PATH")
-fi
-
-if [ ! -d "$SKILL_PATH" ]; then
-    print_error "Skill directory not found: $SKILL_PATH"
-    exit 1
-fi
-
-SKILL_NAME=$(basename "$SKILL_PATH")
-print_info "Selected Skill: \033[1;36m$SKILL_NAME\033[0m ($SKILL_PATH)"
-
-# 2. Define Supported Agents
-# Format: "Name:ProjectDir:GlobalDir"
-AGENTS=(
-    "Claude Code:.claude/skills:$HOME/.claude/skills"
-    "GitHub Copilot:.github/skills:$HOME/.copilot/skills"
-    "Google Antigravity:.agent/skills:$HOME/.gemini/antigravity/skills"
-    "Cursor:.cursor/skills:$HOME/.cursor/skills"
-    "OpenCode:.opencode/skill:$HOME/.config/opencode/skill"
-    "OpenAI Codex:.codex/skills:$HOME/.codex/skills"
-    "Gemini CLI:.gemini/skills:$HOME/.gemini/skills"
-    "Windsurf:.windsurf/skills:$HOME/.codeium/windsurf/skills"
-)
-
-# 3. Agent Selection
-echo ""
-echo "Select Agents to install to (Space to select, Enter to confirm):"
-# Simple multi-select implementation using arrays
-selected_indices=()
-while true; do
-    for i in "${!AGENTS[@]}"; do
-        agent_info="${AGENTS[$i]}"
-        agent_name="${agent_info%%:*}"
-        
-        # Check if selected
-        if [[ " ${selected_indices[*]} " =~ " $i " ]]; then
-            mark="[*]"
-        else
-            mark="[ ]"
-        fi
-        echo "$i) $mark $agent_name"
-    done
-    
-    echo "a) Select All"
-    echo "d) Done"
-    read -p "Select option: " choice
-
-    if [[ "$choice" == "d" ]]; then
-        break
-    elif [[ "$choice" == "a" ]]; then
-        selected_indices=()
-        for i in "${!AGENTS[@]}"; do
-            selected_indices+=("$i")
-        done
-    elif [[ "$choice" =~ ^[0-9]+$ ]] && [ "$choice" -ge 0 ] && [ "$choice" -lt "${#AGENTS[@]}" ]; then
-        if [[ " ${selected_indices[*]} " =~ " $choice " ]]; then
-            # Deselect
-            new_indices=()
-            for idx in "${selected_indices[@]}"; do
-                [[ "$idx" != "$choice" ]] && new_indices+=("$idx")
-            done
-            selected_indices=("${new_indices[@]}")
-        else
-            # Select
-            selected_indices+=("$choice")
-        fi
-    else
-        echo "Invalid choice."
-    fi
-    echo "------------------------"
-done
-
-if [ ${#selected_indices[@]} -eq 0 ]; then
-    print_warning "No agents selected. Exiting."
-    exit 0
-fi
-
-# 4. Process Each Selected Agent
-for idx in "${selected_indices[@]}"; do
-    agent_raw="${AGENTS[$idx]}"
-    IFS=':' read -r agent_name project_dir global_dir <<< "$agent_raw"
-    
-    echo ""
-    print_info "Configuring for \033[1;36m$agent_name\033[0m..."
-    
-    # Scope Selection
-    echo "Select Scope:"
-    echo "1) Project ($project_dir)"
-    echo "2) Global ($global_dir)"
-    echo "3) Both"
-    echo "s) Skip"
-    read -p "Choice [1-3]: " scope_choice
-
-    targets=()
-    case $scope_choice in
-        1) targets+=("$project_dir") ;;
-        2) targets+=("$global_dir") ;;
-        3) targets+=("$project_dir" "$global_dir") ;;
-        s|S) continue ;;
-        *) print_warning "Invalid choice, skipping $agent_name"; continue ;;
-    esac
-
-    for target_base in "${targets[@]}"; do
-        # Resolve path expansion if needed (already expanded in definition for Global, Project is relative)
-        if [[ "$target_base" == /* ]]; then
-            # Absolute path (Global)
-            target_dir="$target_base"
-        else
-            # Relative path (Project) - assume current dir is project root
-            target_dir="$(pwd)/$target_base"
-        fi
-        
-        # Ensure target parent directory exists
-        if [ ! -d "$target_dir" ]; then
-            print_info "Creating directory: $target_dir"
-            mkdir -p "$target_dir"
-        fi
-
-        target_link="$target_dir/$SKILL_NAME"
-
-        # Check for existing link or directory
-        if [ -e "$target_link" ] || [ -L "$target_link" ]; then
-            print_warning "$target_link already exists."
-            read -p "Overwrite? (y/N): " overwrite
-            if [[ "$overwrite" =~ ^[yY]$ ]]; then
-                rm -rf "$target_link"
-            else
-                print_info "Skipping..."
-                continue
-            fi
-        fi
-
-        # Create Symlink
-        ln -s "$SKILL_PATH" "$target_link"
-        if [ $? -eq 0 ]; then
-            print_success "Linked to $target_link"
-        else
-            print_error "Failed to link to $target_link"
-        fi
-    done
-done
-
-echo ""
-print_success "All operations completed."