@nnnggel/skills-management 1.0.0

package/README.md

@@ -0,0 +1,112 @@
+# Skills Management CLI (skm)
+
+[简体中文](./README.zh-CN.md) | English
+
+`skm` is a powerful CLI tool designed to manage and synchronize "skills" (prompt libraries, instruction sets, or capability modules) across various AI coding agents and projects. It serves as a central hub to download skills from GitHub and selectively link them into your local AI project configurations.
+
+It supports multiple AI environments including **OpenCode**, **Cursor**, **Gemini**, **Antigravity**, **Claude**, and **GitHub** projects.
+
+---
+
+## 🚀 Features
+
+- **Global Skill Repository**: Centralized management of your AI skills.
+- **GitHub Integration**: Add skills directly from GitHub repositories or specific subdirectories (sparse checkout).
+- **Version Control**: Check for updates and synchronize changes from remote repositories.
+- **Project Detection**: Automatically detects the AI project type in your current directory.
+- **Symbolic Linking**: Efficiently links skills to projects without duplication, keeping them in sync.
+- **Project Isolation**: Manage different sets of skills for different projects.
+
+## 💡 Why skm?
+
+- **Centralized Efficiency**: Skills are cloned only once (`~/.skills-management/repo`) and shared across infinite projects via symbolic links. This saves significant disk space and ensures all your projects use the same curated version of a skill.
+- **Precision (Sparse Checkout)**: Only download what you need. If a GitHub repository contains hundreds of skills but you only want one, `skm` uses Git's sparse-checkout to download only that specific subdirectory. No more cloning massive repositories for a single prompt file.
+- **Automatic Environment Awareness**: You don't need to know where Cursor, Claude, or OpenCode stores their skills. `skm` automatically detects your project environment and handles the directory structures for you.
+- **Clean & Non-Intrusive**: Since skills are symlinked, your project folder stays clean. No extra `.git` folders or heavy files are added to your project's version control.
+- **Self-healing**: Proactively detects and helps you clean up broken symbolic links if a global skill is deleted.
+- **Version Sync**: One-click check for updates across all your global skills to keep your local "AI brain" sharp.
+
+## 📦 Installation
+
+This tool can be installed directly from npm:
+
+```bash
+npm install -g skills-management
+```
+
+Or install from source:
+
+```bash
+# Clone the repository
+git clone https://github.com/nnnggel/skills-management.git
+cd skills-management
+npm install
+npm run build
+npm link
+```
+
+## 📖 Usage
+
+Run the tool using `skm`:
+
+```bash
+skm
+```
+
+### 1. Global Repository Management (`repo`)
+
+Select **"1. repo"** from the main menu to manage your global collection of skills.
+
+- **Add Skill**: Enter a GitHub URL to download a skill.
+  - Supports full repositories: `https://github.com/user/repo`
+  - Supports specific subfolders: `https://github.com/user/repo/tree/main/path/to/skill`
+- **Update Skills**: Checks for newer commits on the remote GitHub repository and updates your local copy.
+- **Delete Skills**: Remove skills from your global repository.
+
+### 2. Project Skill Management (`list`)
+
+Navigate to your AI project directory and run `skm`. The tool will detect the project type (e.g., `.opencode`, `.cursor`).
+
+Select **"2. list(type)"** to manage skills for the current project.
+
+- **Link/Unlink**: You will see a list of available global skills.
+- **Checkbox Interface**: Use `Space` to select or deselect skills, and `Enter` to confirm.
+- **Symlinks**: Selected skills are symlinked contents from your global repo into your project's skill directory (e.g., `.opencode/skills/`).
+
+### Supported Project Structures
+
+`skm` automatically detects and installs skills into these directories:
+
+| AI Type | Detected Folder | Skills Installation Path |
+|---------|-----------------|--------------------------|
+| **OpenCode** | `.opencode` | `.opencode/skills` |
+| **Cursor** | `.cursor` | `.cursor/skills` |
+| **Gemini** | `.gemini` | `.gemini/skills` |
+| **Antigravity** | `.antigravity` | `.antigravity/skills` |
+| **Claude** | `.claude` | `.claude/skills` |
+| **GitHub** | `.github` | `.github/skills` |
+
+---
+
+## 🏗️ Directory Structure & Internals
+
+`skm` stores its global data and configuration in your home directory at `~/.skills-management`. This architecture ensures that skills are downloaded once and shared across multiple projects.
+
+### Data Layout:
+
+- **`config.json`**: Global configuration file. It stores system-level settings and metadata.
+- **`repo/`**: The heart of the management system.
+    - **`versions.json`**: The skill registry. It tracks all added skills, their unique IDs, current commit hashes (for version control), and original paths.
+    - **`github__[user]__[repo]__[subpath]/`**: Local Git repositories. `skm` flattens the ID (replacing `/` with `__`) to create safe directory names.
+    - **Note**: `skm` handles complex paths like `github:user/repo/path/to/skill` by creating a unique folder like `github__user__repo__path__to__skill`.
+
+### Cross-Platform Compatibility (Windows)
+`skm` is fully compatible with Windows.
+- On **macOS/Linux**, it uses standard symbolic links.
+- On **Windows**, it automatically uses **Directory Junctions** (a type of symbolic link for folders) to ensure capability without requiring Administrator privileges or Developer Mode.
+
+
+
+## 📄 License
+
+ISC

package/README.zh-CN.md

@@ -0,0 +1,112 @@
+# Skills Management CLI (skm)
+
+简体中文 | [English](./README.md)
+
+`skm` 是一个强大的命令行工具，用于在各种 AI 编程代理和项目中管理与同步“技能”（Skills，即提示词库、指令集或能力模块）。它作为一个中心枢纽，帮助你从 GitHub 下载技能，并将其选择性地链接到本地 AI 项目配置中。
+
+支持多种 AI 环境，包括 **OpenCode**、**Cursor**、**Gemini**、**Antigravity**、**Claude** 和 **GitHub** 项目。
+
+---
+
+## 🚀 功能特性
+
+- **全局技能仓库**：集中管理所有的 AI 技能。
+- **GitHub 集成**：直接从 GitHub 仓库或指定子目录添加技能（支持稀疏检出）。
+- **版本控制**：检查远程更新并同步技能版本。
+- **项目检测**：自动检测当前目录下的 AI 项目类型。
+- **软链接管理**：通过符号链接将技能高效注入项目，避免文件复制，保持同步。
+- **项目隔离**：为不同项目配置不同的技能组合。
+
+## 💡 为什么选择 skm?
+
+- **核心效率**：技能仅克隆一次（存储在 `~/.skills-management/repo`），通过符号链接在无限个项目间共享。这不仅极大地节省了磁盘空间，还确保了所有项目使用的技能版本高度统一。
+- **精准下载 (稀疏检出)**：只下载你需要的。如果一个 GitHub 仓库包含几百个技能，而你只需要其中一个，`skm` 会利用 Git 的 `sparse-checkout` 特性仅下载特定的子目录。告别为了一个几 KB 的 Prompt 而克隆整个几百 MB 仓库的时代。
+- **自动化环境感知**：你不需要记住 Cursor、Claude 或 OpenCode 把技能存在哪里。`skm` 会自动识别你的项目环境并处理对应的目录结构。
+- **整洁且无侵入**：由于使用的是软链接，你的项目文件夹保持纯净。不会有额外的 `.git` 文件夹或庞大的二进制文件进入你的项目版本控制。
+- **自我维护**：主动检测并帮助你清理失效的软链接（例如当全局技能被删除时）。
+- **版本同步**：一键检查所有全局技能的远程更新，确保你的“AI 大脑”始终处于最新状态。
+
+## 📦 安装指南
+
+可以直接从 npm 安装：
+
+```bash
+npm install -g skills-management
+```
+
+或者从源码安装：
+
+```bash
+# 克隆仓库
+git clone https://github.com/nnnggel/skills-management.git
+cd skills-management
+
+# 安装依赖并构建
+npm install
+npm run build
+npm link
+```
+
+## 📖 使用指南
+
+直接运行命令 `skm`：
+
+```bash
+skm
+```
+
+### 1. 全局仓库管理 (`repo`)
+
+在主菜单选择 **"1. repo"** 来管理你的全局技能库。
+
+- **添加技能 (Add skill)**：输入 GitHub URL 下载技能。
+  - 支持完整仓库：`https://github.com/user/repo`
+  - 支持特定子目录：`https://github.com/user/repo/tree/main/path/to/skill`
+- **更新技能 (Update)**：自动检查远程仓库是否有新提交，并更新本地副本。
+- **删除技能 (Delete)**：从全局仓库中移除技能。
+
+### 2. 项目技能管理 (`list`)
+
+在你的 AI 项目根目录下运行 `skm`。工具会自动识别项目类型（如 `.opencode`, `.cursor` 等）。
+
+选择 **"2. list(type)"** 来管理当前项目的技能。
+
+- **链接/取消链接 (Link/Unlink)**：显示全局可用技能列表。
+- **复选框交互**：使用 `空格键` 选中或取消选中技能，`回车键` 确认。
+- **自动注入**：选中的技能会以软链接形式注入到项目的技能目录中（例如 `.opencode/skills/`）。
+
+### 支持的项目结构
+
+`skm` 自动识别以下目录结构并安装技能：
+
+| AI 类型 | 识别目录 | 技能安装路径 |
+|---------|-----------------|--------------------------|
+| **OpenCode** | `.opencode` | `.opencode/skills` |
+| **Cursor** | `.cursor` | `.cursor/skills` |
+| **Gemini** | `.gemini` | `.gemini/skills` |
+| **Antigravity** | `.antigravity` | `.antigravity/skills` |
+| **Claude** | `.claude` | `.claude/skills` |
+| **GitHub** | `.github` | `.github/skills` |
+
+---
+
+## 🏗️ 目录结构与运行机制
+
+`skm` 将所有的全局数据和配置存储在用户主目录下的 `~/.skills-management` 文件夹中。这种设计确保了技能只需下载一次，即可在多个项目间共享。
+
+### 内部结构：
+
+- **`config.json`**: 全局配置文件，存储系统级设置和元数据。
+- **`repo/`**: 管理系统的核心目录。
+    - **`versions.json`**: 技能注册表（数据库）。记录了所有已添加技能的 ID、当前 Commit Hash（用于版本追踪）、检出类型和路径信息。
+    - **`github__[user]__[repo]__[subpath]/`**: 本地 Git 仓库存储中心。`skm` 会将 ID 扁平化（将 `/` 替换为 `__`）以创建安全的文件目录名。例如 `github:user/repo/path` 会被存储为 `github__user__repo__path`。
+
+### Windows 兼容性说明
+`skm` 完全兼容 Windows 系统。
+- 在 **macOS/Linux** 上，使用标准的符号链接 (Symbolic Links)。
+- 在 **Windows** 上，工具会自动使用 **Directory Junctions** (目录联接点)。这是 Windows NTFS 文件系统的一种特性，类似于目录的软链接，但通常**不需要管理员权限**即可创建，确保了最佳的开箱即用体验。
+
+
+## 📄 License
+
+ISC

package/dist/index.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/index.js

@@ -0,0 +1,806 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/index.ts
+var import_fs_extra7 = __toESM(require("fs-extra"));
+var import_inquirer3 = __toESM(require("inquirer"));
+
+// src/core/config.ts
+var import_os = __toESM(require("os"));
+var import_path = __toESM(require("path"));
+var import_fs_extra = __toESM(require("fs-extra"));
+var ConfigManager = class {
+  homeDir;
+  repoDir;
+  configFile;
+  constructor() {
+    this.homeDir = import_path.default.join(import_os.default.homedir(), ".skills-management");
+    this.repoDir = import_path.default.join(this.homeDir, "repo");
+    this.configFile = import_path.default.join(this.homeDir, "config.json");
+    this.init();
+  }
+  init() {
+    import_fs_extra.default.ensureDirSync(this.homeDir);
+    import_fs_extra.default.ensureDirSync(this.repoDir);
+    if (!import_fs_extra.default.existsSync(this.configFile)) {
+      import_fs_extra.default.writeJsonSync(this.configFile, { system: import_os.default.platform() }, { spaces: 2 });
+    }
+  }
+  getHomeDir() {
+    return this.homeDir;
+  }
+  getRepoDir() {
+    return this.repoDir;
+  }
+  getSafeName(id) {
+    const parts = id.split(":");
+    if (parts.length < 2) {
+      return id.replace(/\//g, "__");
+    }
+    const type = parts[0];
+    const rest = parts.slice(1).join(":");
+    const safeRest = rest.replace(/\//g, "__");
+    return `${type}__${safeRest}`;
+  }
+  parseSafeName(safeName) {
+    const parts = safeName.split("__");
+    if (parts.length < 2) {
+      return safeName;
+    }
+    const type = parts[0];
+    const rest = parts.slice(1).join("/");
+    return `${type}:${rest}`;
+  }
+  getRepoPath(id) {
+    return import_path.default.join(this.repoDir, this.getSafeName(id));
+  }
+};
+
+// src/core/project.ts
+var import_fs_extra2 = __toESM(require("fs-extra"));
+var import_path2 = __toESM(require("path"));
+var ProjectDetector = class _ProjectDetector {
+  cwd;
+  static AI_TOOLS = [
+    { dir: ".opencode", type: "opencode" },
+    { dir: ".cursor", type: "cursor" },
+    { dir: ".gemini", type: "gemini" },
+    { dir: ".antigravity", type: "antigravity" },
+    { dir: ".claude", type: "claude" },
+    { dir: ".github", type: "github" }
+  ];
+  constructor(cwd = process.cwd()) {
+    this.cwd = cwd;
+  }
+  /**
+   * 检测所有存在的 AI 项目类型
+   */
+  detectAll() {
+    const projects = [];
+    for (const tool of _ProjectDetector.AI_TOOLS) {
+      if (import_fs_extra2.default.existsSync(import_path2.default.join(this.cwd, tool.dir))) {
+        projects.push({
+          type: tool.type,
+          root: this.cwd,
+          skillDir: import_path2.default.join(this.cwd, tool.dir, "skills")
+        });
+      }
+    }
+    return projects;
+  }
+  /**
+   * 检测第一个存在的 AI 项目类型（向后兼容）
+   */
+  detect() {
+    const projects = this.detectAll();
+    if (projects.length > 0) {
+      return projects[0];
+    }
+    return {
+      type: "unknown",
+      root: this.cwd
+    };
+  }
+};
+
+// src/commands/repo.ts
+var import_inquirer = __toESM(require("inquirer"));
+var import_fs_extra5 = __toESM(require("fs-extra"));
+var import_path4 = __toESM(require("path"));
+
+// src/core/skills.ts
+var import_fs_extra3 = __toESM(require("fs-extra"));
+var import_path3 = __toESM(require("path"));
+var SkillRegistry = class {
+  versionsFile;
+  constructor(configManager) {
+    this.versionsFile = import_path3.default.join(configManager.getRepoDir(), "versions.json");
+  }
+  getStoredSkills() {
+    if (!import_fs_extra3.default.existsSync(this.versionsFile)) {
+      return {};
+    }
+    return import_fs_extra3.default.readJsonSync(this.versionsFile);
+  }
+  saveSkills(skills) {
+    import_fs_extra3.default.writeJsonSync(this.versionsFile, skills, { spaces: 2 });
+  }
+  addSkill(id, commitId, type, skillPath) {
+    const skills = this.getStoredSkills();
+    skills[id] = { commitId, type, path: skillPath };
+    this.saveSkills(skills);
+  }
+  removeSkill(id) {
+    const skills = this.getStoredSkills();
+    delete skills[id];
+    this.saveSkills(skills);
+  }
+  getSkill(id) {
+    const skills = this.getStoredSkills();
+    const stored = skills[id];
+    if (!stored) return void 0;
+    return { id, ...stored };
+  }
+  updateSkillVersion(id, newCommitId) {
+    const skills = this.getStoredSkills();
+    if (skills[id]) {
+      skills[id].commitId = newCommitId;
+      this.saveSkills(skills);
+    }
+  }
+  getAllSkills() {
+    const skills = this.getStoredSkills();
+    return Object.entries(skills).map(([id, stored]) => ({ id, ...stored }));
+  }
+};
+
+// src/core/git.ts
+var import_execa = require("execa");
+var import_fs_extra4 = __toESM(require("fs-extra"));
+var GitManager = class {
+  async checkGitVersion() {
+    try {
+      const { stdout } = await (0, import_execa.execa)("git", ["--version"]);
+      const match = stdout.match(/git version (\d+)\.(\d+)/);
+      if (match) {
+        const major = parseInt(match[1], 10);
+        const minor = parseInt(match[2], 10);
+        if (major < 2 || major === 2 && minor < 25) {
+          throw new Error(`Git version must be >= 2.25. Found ${major}.${minor}`);
+        }
+      } else {
+        throw new Error("Could not parse git version");
+      }
+    } catch (error) {
+      throw new Error(`Failed to check git version: ${error}`);
+    }
+  }
+  normalizeUrl(inputUrl) {
+    let url = inputUrl.replace(/\/+$/, "");
+    url = url.split("?")[0].split("#")[0];
+    url = url.replace(/\.git$/, "");
+    const treePathMatch = url.match(/^(https:\/\/github\.com\/[^\/]+\/[^\/]+)\/tree\/([^\/]+)\/(.+)$/);
+    if (treePathMatch) {
+      const pathValue = treePathMatch[3].replace(/\/+$/, "");
+      return {
+        url: `${treePathMatch[1]}.git`,
+        branch: treePathMatch[2],
+        path: pathValue
+      };
+    }
+    const treeBranchMatch = url.match(/^(https:\/\/github\.com\/[^\/]+\/[^\/]+)\/tree\/([^\/]+)$/);
+    if (treeBranchMatch) {
+      return {
+        url: `${treeBranchMatch[1]}.git`,
+        branch: treeBranchMatch[2]
+        // 无 path，表示根目录
+      };
+    }
+    return {
+      url: `${url}.git`
+    };
+  }
+  async getRemoteHead(url, branch = "HEAD") {
+    const { stdout } = await (0, import_execa.execa)("git", ["ls-remote", url, branch]);
+    const match = stdout.match(/^([a-f0-9]+)\t/);
+    if (match) {
+      return match[1];
+    }
+    throw new Error(`Could not get remote HEAD for ${url} ${branch}`);
+  }
+  async cloneFull(url, dest) {
+    await (0, import_execa.execa)("git", ["clone", url, dest]);
+  }
+  async cloneSparse(url, dest, subPath, branch = "main") {
+    await (0, import_execa.execa)("git", ["clone", "--filter=blob:none", "--no-checkout", url, dest]);
+    await (0, import_execa.execa)("git", ["sparse-checkout", "init", "--cone"], { cwd: dest });
+    await (0, import_execa.execa)("git", ["sparse-checkout", "set", subPath], { cwd: dest });
+    await (0, import_execa.execa)("git", ["checkout", branch], { cwd: dest });
+  }
+  async pull(cwd) {
+    await (0, import_execa.execa)("git", ["pull"], { cwd });
+  }
+  async fetch(cwd) {
+    await (0, import_execa.execa)("git", ["fetch", "origin"], { cwd });
+  }
+  /**
+   * 检查远程仓库中的 SKILL.md 是否存在
+   * 使用 git ls-remote + git ls-tree 检查文件
+   */
+  async checkRemoteSkillMd(userRepo, branch = "main", subPath) {
+    const url = `https://github.com/${userRepo}.git`;
+    const skillPath = subPath ? `${subPath}/SKILL.md` : "SKILL.md";
+    try {
+      const { stdout: refStdout } = await (0, import_execa.execa)("git", ["ls-remote", url, `refs/heads/${branch}`]);
+      const commitMatch = refStdout.match(/^([a-f0-9]+)\t/);
+      if (!commitMatch) {
+        return false;
+      }
+      const commitHash = commitMatch[1];
+      await (0, import_execa.execa)("git", ["archive", "--remote", url, commitHash, skillPath]);
+      return true;
+    } catch {
+      try {
+        const tmpDir = `/tmp/skm-check-${Date.now()}`;
+        try {
+          await (0, import_execa.execa)("git", ["clone", "--depth=1", "--filter=blob:none", "--no-checkout", url, tmpDir]);
+          await (0, import_execa.execa)("git", ["sparse-checkout", "init", "--cone"], { cwd: tmpDir });
+          await (0, import_execa.execa)("git", ["sparse-checkout", "set", subPath || "."], { cwd: tmpDir });
+          await (0, import_execa.execa)("git", ["checkout", branch], { cwd: tmpDir });
+          const skillMdPath = subPath ? `${tmpDir}/${subPath}/SKILL.md` : `${tmpDir}/SKILL.md`;
+          const exists = import_fs_extra4.default.existsSync(skillMdPath);
+          await import_fs_extra4.default.remove(tmpDir);
+          return exists;
+        } catch {
+          await import_fs_extra4.default.remove(tmpDir).catch(() => {
+          });
+          return false;
+        }
+      } catch {
+        return false;
+      }
+    }
+  }
+  /**
+   * 获取远程仓库默认分支
+   * 使用 git ls-remote 获取 HEAD 引用
+   */
+  async getDefaultBranch(userRepo) {
+    const url = `https://github.com/${userRepo}.git`;
+    try {
+      const { stdout } = await (0, import_execa.execa)("git", ["ls-remote", "--symref", url, "HEAD"]);
+      const match = stdout.match(/ref: refs\/heads\/([^\t\n]+)/);
+      if (match) {
+        return match[1];
+      }
+    } catch {
+    }
+    return "main";
+  }
+  /**
+   * 从本地仓库获取指定路径的最新 commit id
+   * 用于已经 clone 到本地的仓库
+   */
+  async getLocalPathCommitId(repoDir, subPath) {
+    try {
+      const { stdout: stdout2 } = await (0, import_execa.execa)("git", ["log", "-1", "--format=%H", "--", subPath], { cwd: repoDir });
+      if (stdout2.trim()) {
+        return stdout2.trim();
+      }
+    } catch {
+    }
+    const { stdout } = await (0, import_execa.execa)("git", ["rev-parse", "HEAD"], { cwd: repoDir });
+    return stdout.trim();
+  }
+  /**
+   * 获取远程分支中指定路径的最新 commit id
+   * 用于更新检测（在 fetch 之后使用）
+   */
+  async getRemotePathCommitId(repoDir, remoteBranch, subPath) {
+    try {
+      const { stdout: stdout2 } = await (0, import_execa.execa)("git", ["log", "-1", "--format=%H", remoteBranch, "--", subPath], { cwd: repoDir });
+      if (stdout2.trim()) {
+        return stdout2.trim();
+      }
+    } catch {
+    }
+    const { stdout } = await (0, import_execa.execa)("git", ["rev-parse", remoteBranch], { cwd: repoDir });
+    return stdout.trim();
+  }
+};
+
+// src/commands/repo.ts
+async function repoMenu() {
+  const configManager = new ConfigManager();
+  const skillRegistry = new SkillRegistry(configManager);
+  while (true) {
+    const skills = skillRegistry.getAllSkills().sort((a, b) => a.id.localeCompare(b.id));
+    console.log("\n=== Repository Management ===");
+    console.log("a. Add skill");
+    console.log("---");
+    const menuMap = {
+      "a": { action: "add" },
+      "0": { action: "back" }
+    };
+    if (skills.length === 0) {
+      console.log("(No skills in repository)");
+    } else {
+      skills.forEach((s, index) => {
+        const num = (index + 1).toString();
+        console.log(`${num}. ${s.id}:${s.commitId.substring(0, 7)}`);
+        menuMap[num] = { action: "manage", skill: s };
+      });
+    }
+    console.log("---");
+    console.log("0. Back to main menu");
+    const answer = await import_inquirer.default.prompt([
+      {
+        type: "input",
+        name: "choice",
+        message: "Select an option:",
+        validate: (input) => menuMap[input.toLowerCase()] ? true : "Invalid option"
+      }
+    ]);
+    const choice = menuMap[answer.choice.toLowerCase()];
+    const { action, skill } = choice;
+    if (action === "back") {
+      break;
+    } else if (action === "add") {
+      await addSkillInteractive();
+    } else if (action === "manage" && skill) {
+      await manageSkill(skill);
+    }
+  }
+}
+async function checkSingleSkillUpdate(skill) {
+  const configManager = new ConfigManager();
+  const gitManager = new GitManager();
+  if (skill.type !== "github") return null;
+  try {
+    const parts = skill.id.split(":");
+    if (parts.length < 2) return null;
+    const repoPath = parts[1];
+    let userRepo = repoPath;
+    if (skill.path) {
+      if (repoPath.endsWith(skill.path)) {
+        userRepo = repoPath.substring(0, repoPath.length - skill.path.length - 1);
+      }
+    }
+    const url = `https://github.com/${userRepo}.git`;
+    const localRepoDir = configManager.getRepoPath(skill.id);
+    let localCommit;
+    if (skill.path) {
+      localCommit = await gitManager.getLocalPathCommitId(localRepoDir, skill.path);
+    } else {
+      localCommit = await gitManager.getLocalPathCommitId(localRepoDir, ".");
+    }
+    console.log("Checking for updates...");
+    await gitManager.fetch(localRepoDir);
+    const branch = await gitManager.getDefaultBranch(userRepo);
+    let remoteHead;
+    if (skill.path) {
+      remoteHead = await gitManager.getRemotePathCommitId(localRepoDir, `origin/${branch}`, skill.path);
+    } else {
+      remoteHead = await gitManager.getRemotePathCommitId(localRepoDir, `origin/${branch}`, ".");
+    }
+    if (remoteHead && remoteHead !== localCommit) {
+      return { skill, url, remoteHead, branch };
+    }
+  } catch (error) {
+    console.error(`Failed to check update: ${error.message}`);
+  }
+  return null;
+}
+async function manageSkill(skill) {
+  console.log(`
+=== Manage: ${skill.id} ===`);
+  const update = await checkSingleSkillUpdate(skill);
+  const hasUpdate = update !== null;
+  const menuMap = {
+    "0": "back"
+  };
+  let optionNum = 1;
+  if (hasUpdate && update) {
+    console.log(`${optionNum}. Update (${skill.commitId.substring(0, 7)} -> ${update.remoteHead.substring(0, 7)})`);
+    menuMap[optionNum.toString()] = "update";
+    optionNum++;
+  } else {
+    console.log("(No updates available)");
+  }
+  console.log(`${optionNum}. Delete`);
+  menuMap[optionNum.toString()] = "delete";
+  console.log("0. Back");
+  const answer = await import_inquirer.default.prompt([
+    {
+      type: "input",
+      name: "action",
+      message: "Select an option:",
+      validate: (input) => menuMap[input] ? true : "Invalid option"
+    }
+  ]);
+  const action = menuMap[answer.action];
+  if (action === "update" && update) {
+    await updateSingleSkill(skill, update);
+  } else if (action === "delete") {
+    await deleteSkill(skill.id);
+  }
+}
+async function updateSingleSkill(skill, update) {
+  const configManager = new ConfigManager();
+  const skillRegistry = new SkillRegistry(configManager);
+  const gitManager = new GitManager();
+  try {
+    console.log(`Updating ${skill.id}...`);
+    const destPath = configManager.getRepoPath(skill.id);
+    await gitManager.pull(destPath);
+    skillRegistry.updateSkillVersion(skill.id, update.remoteHead);
+    console.log(`Updated ${skill.id}`);
+  } catch (error) {
+    console.error(`Failed to update ${skill.id}: ${error.message}`);
+  }
+}
+async function addSkillInteractive(url) {
+  const configManager = new ConfigManager();
+  const skillRegistry = new SkillRegistry(configManager);
+  const gitManager = new GitManager();
+  let repoUrl = url;
+  if (!repoUrl) {
+    const answer = await import_inquirer.default.prompt([
+      {
+        type: "input",
+        name: "url",
+        message: "Enter GitHub URL:",
+        validate: (input) => input.length > 0 || "URL is required"
+      }
+    ]);
+    repoUrl = answer.url;
+  }
+  if (!repoUrl) return;
+  try {
+    await gitManager.checkGitVersion();
+    const gitInfo = gitManager.normalizeUrl(repoUrl);
+    const match = gitInfo.url.match(/github\.com\/([^\/]+\/[^\/]+)(\.git)?$/);
+    if (!match) {
+      throw new Error("Only GitHub URLs are supported for now.");
+    }
+    const userRepo = match[1].replace(/\.git$/, "");
+    const branch = gitInfo.branch || await gitManager.getDefaultBranch(userRepo);
+    console.log("Checking for SKILL.md...");
+    const hasSkillMd = await gitManager.checkRemoteSkillMd(userRepo, branch, gitInfo.path);
+    if (!hasSkillMd) {
+      console.error("Error: SKILL.md not found at the specified path.");
+      console.error(`Expected location: https://github.com/${userRepo}/blob/${branch}/${gitInfo.path ? gitInfo.path + "/" : ""}SKILL.md`);
+      return;
+    }
+    let id = `github:${userRepo}`;
+    if (gitInfo.path) {
+      id += `/${gitInfo.path}`;
+    }
+    const existingSkill = skillRegistry.getSkill(id);
+    if (existingSkill) {
+      const confirm = await import_inquirer.default.prompt([
+        {
+          type: "confirm",
+          name: "overwrite",
+          message: `Skill ${id} already exists. Overwrite?`,
+          default: false
+        }
+      ]);
+      if (!confirm.overwrite) {
+        console.log("Operation cancelled.");
+        return;
+      }
+      await import_fs_extra5.default.remove(configManager.getRepoPath(id));
+    }
+    const destPath = configManager.getRepoPath(id);
+    import_fs_extra5.default.ensureDirSync(import_path4.default.dirname(destPath));
+    console.log(`Cloning ${id}...`);
+    if (gitInfo.path) {
+      await gitManager.cloneSparse(gitInfo.url, destPath, gitInfo.path, branch);
+    } else {
+      await gitManager.cloneFull(gitInfo.url, destPath);
+    }
+    let commitId;
+    if (gitInfo.path) {
+      commitId = await gitManager.getLocalPathCommitId(destPath, gitInfo.path);
+    } else {
+      commitId = await gitManager.getLocalPathCommitId(destPath, ".");
+    }
+    skillRegistry.addSkill(id, commitId, "github", gitInfo.path);
+    console.log(`Skill ${id} added successfully.`);
+  } catch (error) {
+    console.error(`Failed to add skill: ${error.message}`);
+  }
+}
+async function deleteSkill(id) {
+  const configManager = new ConfigManager();
+  const skillRegistry = new SkillRegistry(configManager);
+  let skillId = id;
+  if (!skillId) {
+    const skills = skillRegistry.getAllSkills();
+    if (skills.length === 0) {
+      console.log("No skills to delete.");
+      return;
+    }
+    const answer = await import_inquirer.default.prompt([
+      {
+        type: "list",
+        name: "skillId",
+        message: "Select a skill to delete:",
+        choices: skills.map((s) => s.id)
+      }
+    ]);
+    skillId = answer.skillId;
+  }
+  if (!skillId) return;
+  const confirm = await import_inquirer.default.prompt([
+    {
+      type: "confirm",
+      name: "sure",
+      message: `Are you sure you want to delete ${skillId}?`,
+      default: false
+    }
+  ]);
+  if (confirm.sure) {
+    const repoPath = configManager.getRepoPath(skillId);
+    await import_fs_extra5.default.remove(repoPath);
+    skillRegistry.removeSkill(skillId);
+    console.log(`Skill ${skillId} deleted.`);
+  } else {
+    console.log("Deletion cancelled.");
+  }
+}
+
+// src/commands/project.ts
+var import_inquirer2 = __toESM(require("inquirer"));
+var import_fs_extra6 = __toESM(require("fs-extra"));
+var import_path5 = __toESM(require("path"));
+var import_os2 = __toESM(require("os"));
+async function linkSkillToProject(skillId, projectInfo) {
+  const configManager = new ConfigManager();
+  const skillRegistry = new SkillRegistry(configManager);
+  if (!projectInfo.skillDir) {
+    console.log("No skill directory for this project.");
+    return;
+  }
+  const skill = skillRegistry.getSkill(skillId);
+  if (!skill) {
+    console.log(`Skill ${skillId} not found in repository.`);
+    return;
+  }
+  import_fs_extra6.default.ensureDirSync(projectInfo.skillDir);
+  const safeName = configManager.getSafeName(skill.id);
+  const linkPath = import_path5.default.join(projectInfo.skillDir, safeName);
+  const repoPath = configManager.getRepoPath(skill.id);
+  let targetPath = repoPath;
+  if (skill.path) {
+    targetPath = import_path5.default.join(repoPath, skill.path);
+  }
+  if (import_fs_extra6.default.existsSync(linkPath)) {
+    console.log(`Skill ${skillId} is already linked.`);
+    return;
+  }
+  try {
+    const type = import_os2.default.platform() === "win32" ? "junction" : "dir";
+    await import_fs_extra6.default.ensureSymlink(targetPath, linkPath, type);
+    console.log(`Linked ${skill.id}`);
+  } catch (error) {
+    console.error(`Failed to link ${skill.id}: ${error.message}`);
+  }
+}
+async function unlinkSkillFromProject(skillId, projectInfo) {
+  const configManager = new ConfigManager();
+  if (!projectInfo.skillDir) {
+    console.log("No skill directory for this project.");
+    return;
+  }
+  const safeName = configManager.getSafeName(skillId);
+  const linkPath = import_path5.default.join(projectInfo.skillDir, safeName);
+  if (!import_fs_extra6.default.existsSync(linkPath)) {
+    console.log(`Skill ${skillId} is not linked.`);
+    return;
+  }
+  try {
+    await import_fs_extra6.default.remove(linkPath);
+    console.log(`Unlinked ${skillId}`);
+  } catch (error) {
+    console.error(`Failed to unlink ${skillId}: ${error.message}`);
+  }
+}
+function findBrokenLinks(skillDir) {
+  const broken = [];
+  if (!import_fs_extra6.default.existsSync(skillDir)) {
+    return broken;
+  }
+  const entries = import_fs_extra6.default.readdirSync(skillDir);
+  for (const entry of entries) {
+    const linkPath = import_path5.default.join(skillDir, entry);
+    try {
+      const stats = import_fs_extra6.default.lstatSync(linkPath);
+      if (stats.isSymbolicLink()) {
+        const target = import_fs_extra6.default.readlinkSync(linkPath);
+        if (!import_fs_extra6.default.existsSync(target)) {
+          broken.push(entry);
+        }
+      }
+    } catch {
+    }
+  }
+  return broken;
+}
+async function manageProjectSkills(projectInfo) {
+  const configManager = new ConfigManager();
+  const skillRegistry = new SkillRegistry(configManager);
+  if (!projectInfo) {
+    const projectDetector = new ProjectDetector();
+    projectInfo = projectDetector.detect();
+  }
+  if (projectInfo.type === "unknown" || !projectInfo.skillDir) {
+    console.log("No supported AI project detected in current directory.");
+    return;
+  }
+  console.log(`
+Managing ${projectInfo.type} project skills`);
+  console.log(`Skill directory: ${projectInfo.skillDir}
+`);
+  import_fs_extra6.default.ensureDirSync(projectInfo.skillDir);
+  const brokenLinks = findBrokenLinks(projectInfo.skillDir);
+  if (brokenLinks.length > 0) {
+    console.log("\u26A0 Found broken symlinks:");
+    for (const link of brokenLinks) {
+      console.log(`  - ${link}`);
+    }
+    const cleanupAnswer = await import_inquirer2.default.prompt([
+      {
+        type: "confirm",
+        name: "cleanup",
+        message: "Remove broken symlinks?",
+        default: true
+      }
+    ]);
+    if (cleanupAnswer.cleanup) {
+      for (const link of brokenLinks) {
+        const linkPath = import_path5.default.join(projectInfo.skillDir, link);
+        await import_fs_extra6.default.remove(linkPath);
+        console.log(`Removed broken link: ${link}`);
+      }
+    }
+    console.log("");
+  }
+  const skills = skillRegistry.getAllSkills().sort((a, b) => a.id.localeCompare(b.id));
+  if (skills.length === 0) {
+    console.log('No skills in global repository. Add skills first using "repo" menu.');
+    return;
+  }
+  const getLinkedSkills = () => {
+    const linked = /* @__PURE__ */ new Set();
+    for (const skill of skills) {
+      const safeName = configManager.getSafeName(skill.id);
+      const linkPath = import_path5.default.join(projectInfo.skillDir, safeName);
+      if (import_fs_extra6.default.existsSync(linkPath)) {
+        linked.add(skill.id);
+      }
+    }
+    return linked;
+  };
+  const linkedSkills = getLinkedSkills();
+  console.log("\n=== Link/Unlink Skills ===");
+  console.log("Use space to select/unselect, enter to confirm:\n");
+  const answer = await import_inquirer2.default.prompt([
+    {
+      type: "checkbox",
+      name: "selected",
+      message: "Select skills to link:",
+      choices: skills.map((skill) => ({
+        name: skill.id,
+        value: skill.id,
+        checked: linkedSkills.has(skill.id)
+      }))
+    }
+  ]);
+  const selectedSet = new Set(answer.selected);
+  for (const skill of skills) {
+    const isCurrentlyLinked = linkedSkills.has(skill.id);
+    const shouldBeLinked = selectedSet.has(skill.id);
+    if (!isCurrentlyLinked && shouldBeLinked) {
+      await linkSkillToProject(skill.id, projectInfo);
+    } else if (isCurrentlyLinked && !shouldBeLinked) {
+      await unlinkSkillFromProject(skill.id, projectInfo);
+    }
+  }
+}
+
+// src/index.ts
+async function showConfig() {
+  const configManager = new ConfigManager();
+  console.log(`
+Config Directory: ${configManager.getHomeDir()}`);
+  const configFile = `${configManager.getHomeDir()}/config.json`;
+  if (import_fs_extra7.default.existsSync(configFile)) {
+    const config = import_fs_extra7.default.readJsonSync(configFile);
+    console.log("Configuration:", JSON.stringify(config, null, 2));
+  }
+}
+async function mainMenu() {
+  const projectDetector = new ProjectDetector();
+  while (true) {
+    const projects = projectDetector.detectAll();
+    console.log("\n=== Skills Management (skm) ===");
+    console.log("1. repo - Manage global skills repository");
+    const menuMap = {
+      "1": { action: "repo" }
+    };
+    let currentIndex = 2;
+    for (const project2 of projects) {
+      console.log(`${currentIndex}. list(${project2.type}) - Manage skills for ${project2.type}`);
+      menuMap[currentIndex.toString()] = { action: "list", project: project2 };
+      currentIndex++;
+    }
+    console.log("0. Exit");
+    menuMap["0"] = { action: "exit" };
+    const answer = await import_inquirer3.default.prompt([
+      {
+        type: "input",
+        name: "choice",
+        message: "Select an option (enter number):",
+        validate: (input) => menuMap[input] ? true : "Invalid option"
+      }
+    ]);
+    const { action, project } = menuMap[answer.choice];
+    if (action === "exit") {
+      process.exit(0);
+    } else if (action === "repo") {
+      await repoMenu();
+    } else if (action === "list" && project) {
+      await manageProjectSkills(project);
+    }
+  }
+}
+async function main() {
+  const args = process.argv.slice(2);
+  if (args.includes("--config")) {
+    await showConfig();
+    return;
+  }
+  if (args.includes("--help") || args.includes("-h")) {
+    console.log(`
+Skills Management CLI (skm)
+
+Usage:
+  skm           Enter interactive mode
+  skm --config  View configuration
+`);
+    return;
+  }
+  await mainMenu();
+}
+main().catch((error) => {
+  if (error.name === "ExitPromptError" || error.message?.includes("force closed")) {
+    console.log("\nHave a nice Day!");
+    process.exit(0);
+  }
+  console.error(error);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@nnnggel/skills-management",
+  "version": "1.0.0",
+  "main": "index.js",
+  "description": "A CLI tool to manage and synchronize AI coding agent skills",
+  "bin": {
+    "skm": "./dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "test": "vitest run",
+    "build": "tsup src/index.ts --format cjs --clean --dts",
+    "prepublishOnly": "npm run build"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "ai",
+    "skills",
+    "cli",
+    "management",
+    "agent"
+  ],
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "commander": "^14.0.2",
+    "execa": "^9.6.1",
+    "fs-extra": "^11.3.3",
+    "inquirer": "^13.2.1",
+    "zod": "^4.3.6"
+  },
+  "devDependencies": {
+    "@types/fs-extra": "^11.0.4",
+    "@types/inquirer": "^9.0.9",
+    "@types/node": "^25.0.10",
+    "tsup": "^8.3.6",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.18"
+  }
+}