addx-skills 1.0.0

package/README.md

@@ -0,0 +1,153 @@
+# addx-skills
+
+从公司私有 GitLab 仓库 (`engineering/skills`) 搜索和安装 AI Agent Skills 的 CLI 工具。
+
+## 快速开始
+
+```bash
+# 搜索所有可用 Skills
+npx addx-skills find
+
+# 按关键词搜索
+npx addx-skills find "sql"
+npx addx-skills find "安全检查"
+
+# 安装 Skill（默认安装到当前项目 .agents/skills/）
+npx addx-skills add security/sql-injection
+
+# 安装到全局（所有项目可用）
+npx addx-skills add dev-standards-review -g
+```
+
+## 前置条件
+
+- **Node.js >= 18**
+- **Git 凭证**：能通过 `git clone` 访问 `gitlab.addx.ai`（SSH key 或 HTTPS credential helper）
+
+无需额外配置 Token，复用系统已有的 git 凭证。
+
+## 命令
+
+### `find [query]` — 搜索 Skills
+
+```bash
+npx addx-skills find              # 列出全部
+npx addx-skills find "sql"        # 按关键词搜索
+npx addx-skills find --no-cache   # 强制刷新缓存后搜索
+```
+
+搜索按以下优先级匹配：Skill ID > name > description > 全文内容。
+
+### `add <skill-id>` — 安装 Skill
+
+```bash
+npx addx-skills add security/sql-injection            # 安装到当前项目（默认）
+npx addx-skills add security/sql-injection -g          # 安装到全局
+npx addx-skills add security/sql-injection -a claude-code  # 指定 Agent
+npx addx-skills add security/sql-injection --force     # 强制覆盖
+```
+
+支持的 Agent：`cursor`（默认）、`claude-code`、`codex`、`antigravity`
+
+### `list` / `ls` — 列出已安装
+
+```bash
+npx addx-skills list
+npx addx-skills ls --global    # 仅全局
+npx addx-skills ls --project   # 仅当前项目
+```
+
+### `remove` / `rm` — 卸载 Skill
+
+```bash
+npx addx-skills remove security/sql-injection
+npx addx-skills rm dev-standards-review -g   # 从全局卸载
+```
+
+### `check` — 检查更新
+
+```bash
+npx addx-skills check   # 检查已安装 Skills 是否有更新
+```
+
+### `update` — 更新
+
+```bash
+npx addx-skills update          # 更新缓存 + 已安装的 Skills
+npx addx-skills update --cache  # 仅更新缓存
+```
+
+### `config` — 配置管理
+
+```bash
+npx addx-skills config                          # 查看当前配置
+npx addx-skills config --repo <url>             # 设置自定义仓库
+npx addx-skills config --branch develop         # 设置分支
+npx addx-skills config --cache-ttl 7200         # 设置缓存有效期（秒）
+```
+
+## 配置
+
+默认零配置。可通过环境变量或配置文件自定义：
+
+| 配置项 | 环境变量 | 默认值 |
+|--------|----------|--------|
+| Skills 仓库 URL | `ADDX_SKILLS_REPO` | `https://gitlab.addx.ai/engineering/skills.git` |
+| 默认分支 | `ADDX_SKILLS_BRANCH` | `main` |
+| 缓存过期时间 | `ADDX_SKILLS_CACHE_TTL` | `3600`（秒） |
+
+配置文件路径：`~/.config/addx-skills/config.json`
+
+## 与官方 CLI 的关系
+
+```
+npx skills find "xxx"        → 搜索公共 skills.sh 市场
+npx skills add <url>         → 从任意 Git 源安装
+
+npx addx-skills find "xxx"   → 搜索公司私有 GitLab 仓库（本工具）
+npx addx-skills add <id>     → 从私有仓库安装（本工具）
+```
+
+两个工具互补共存，不冲突。命令和选项风格与官方 CLI 保持一致。
+
+## 开发
+
+```bash
+npm install
+npm run build       # 构建
+npm run typecheck   # 类型检查
+npm run dev         # 开发模式（watch）
+npm test            # 运行测试
+```
+
+## 发布
+
+```bash
+# 1. 确保在 main 分支且代码最新
+git checkout main && git pull
+
+# 2. 升版本（自动修改 package.json + git commit + git tag）
+npm version patch   # bug 修复: 1.0.0 → 1.0.1
+npm version minor   # 新功能:   1.0.0 → 1.1.0
+npm version major   # 破坏性:   1.0.0 → 2.0.0
+
+# 3. 推送，CI 自动 npm publish
+git push origin main --tags
+```
+
+首次发布（已是 `1.0.0`）可直接打 tag：
+
+```bash
+git tag v1.0.0 && git push origin v1.0.0
+```
+
+## 技术栈
+
+| 组件 | 技术 |
+|------|------|
+| 语言 | TypeScript |
+| 运行时 | Node.js >= 18 |
+| 构建 | tsup |
+| Git 操作 | simple-git |
+| Frontmatter 解析 | gray-matter |
+| 交互式 UI | @clack/prompts |

package/dist/cli.js

@@ -0,0 +1,771 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import * as p8 from "@clack/prompts";
+
+// src/commands/find.ts
+import * as p from "@clack/prompts";
+
+// src/lib/cache.ts
+import fs2 from "fs";
+import path3 from "path";
+import simpleGit from "simple-git";
+
+// src/lib/constants.ts
+import path from "path";
+import os from "os";
+var DEFAULT_REPO = "https://gitlab.addx.ai/engineering/skills.git";
+var DEFAULT_BRANCH = "main";
+var DEFAULT_CACHE_TTL = 3600;
+function getCacheDir() {
+  const cacheBase = process.env.XDG_CACHE_HOME || path.join(os.homedir(), ".cache");
+  return path.join(cacheBase, "addx-skills", "skills-repo");
+}
+function getConfigPath() {
+  const configBase = process.env.XDG_CONFIG_HOME || path.join(os.homedir(), ".config");
+  return path.join(configBase, "addx-skills", "config.json");
+}
+var EXCLUDED_DIRS = [
+  ".config",
+  ".cursor",
+  ".git",
+  ".gitlab",
+  ".specstory",
+  "docs",
+  "scripts",
+  "templates"
+];
+var AGENT_PATHS = {
+  cursor: {
+    global: path.join(os.homedir(), ".cursor", "skills"),
+    project: path.join(".agents", "skills")
+  },
+  "claude-code": {
+    global: path.join(os.homedir(), ".claude", "skills"),
+    project: path.join(".claude", "skills")
+  },
+  codex: {
+    global: path.join(os.homedir(), ".codex", "skills"),
+    project: path.join(".agents", "skills")
+  },
+  antigravity: {
+    global: path.join(os.homedir(), ".gemini", "antigravity", "skills"),
+    project: path.join(".agent", "skills")
+  }
+};
+var DEFAULT_AGENT = "cursor";
+var DEFAULT_CONFIG = {
+  repo: DEFAULT_REPO,
+  branch: DEFAULT_BRANCH,
+  cacheTTL: DEFAULT_CACHE_TTL
+};
+
+// src/lib/config.ts
+import fs from "fs";
+import path2 from "path";
+function loadConfig() {
+  const fileConfig = readConfigFile();
+  return {
+    repo: process.env.ADDX_SKILLS_REPO || fileConfig.repo || DEFAULT_REPO,
+    branch: process.env.ADDX_SKILLS_BRANCH || fileConfig.branch || DEFAULT_BRANCH,
+    cacheTTL: process.env.ADDX_SKILLS_CACHE_TTL ? parseInt(process.env.ADDX_SKILLS_CACHE_TTL, 10) : fileConfig.cacheTTL ?? DEFAULT_CACHE_TTL
+  };
+}
+function readConfigFile() {
+  const configPath = getConfigPath();
+  try {
+    if (fs.existsSync(configPath)) {
+      const raw = fs.readFileSync(configPath, "utf-8");
+      return JSON.parse(raw);
+    }
+  } catch {
+  }
+  return {};
+}
+function saveConfig(updates) {
+  const configPath = getConfigPath();
+  const current = readConfigFile();
+  const merged = { ...DEFAULT_CONFIG, ...current, ...updates };
+  fs.mkdirSync(path2.dirname(configPath), { recursive: true });
+  fs.writeFileSync(configPath, JSON.stringify(merged, null, 2) + "\n", "utf-8");
+}
+function getEffectiveConfig() {
+  const fileConfig = readConfigFile();
+  const configPath = getConfigPath();
+  const source = {};
+  const result = loadConfig();
+  for (const key of ["repo", "branch", "cacheTTL"]) {
+    if (key === "cacheTTL" && process.env.ADDX_SKILLS_CACHE_TTL) {
+      source[key] = "env: ADDX_SKILLS_CACHE_TTL";
+    } else if (key === "repo" && process.env.ADDX_SKILLS_REPO) {
+      source[key] = "env: ADDX_SKILLS_REPO";
+    } else if (key === "branch" && process.env.ADDX_SKILLS_BRANCH) {
+      source[key] = "env: ADDX_SKILLS_BRANCH";
+    } else if (fileConfig[key] !== void 0) {
+      source[key] = `file: ${configPath}`;
+    } else {
+      source[key] = "default";
+    }
+  }
+  return { ...result, configPath, source };
+}
+
+// src/lib/cache.ts
+function isCacheValid(cacheDir, ttlSeconds) {
+  const marker = path3.join(cacheDir, ".git", "HEAD");
+  try {
+    const stat = fs2.statSync(marker);
+    const ageMs = Date.now() - stat.mtimeMs;
+    return ageMs < ttlSeconds * 1e3;
+  } catch {
+    return false;
+  }
+}
+function touchCache(cacheDir) {
+  const marker = path3.join(cacheDir, ".git", "HEAD");
+  try {
+    const now = /* @__PURE__ */ new Date();
+    fs2.utimesSync(marker, now, now);
+  } catch {
+  }
+}
+function isGitRepo(dir) {
+  return fs2.existsSync(path3.join(dir, ".git", "HEAD"));
+}
+async function syncCache(options) {
+  const config = loadConfig();
+  const cacheDir = getCacheDir();
+  if (options?.noCache && isGitRepo(cacheDir)) {
+    return forceUpdate(cacheDir, config.branch);
+  }
+  if (!isGitRepo(cacheDir)) {
+    return cloneRepo(cacheDir, config.repo, config.branch);
+  }
+  if (!isCacheValid(cacheDir, config.cacheTTL)) {
+    return updateRepo(cacheDir, config.branch);
+  }
+  return { status: "cached", cacheDir };
+}
+async function cloneRepo(cacheDir, repo, branch) {
+  fs2.mkdirSync(path3.dirname(cacheDir), { recursive: true });
+  const git = simpleGit();
+  await git.clone(repo, cacheDir, ["--depth", "1", "--branch", branch, "--single-branch"]);
+  return { status: "cloned", cacheDir };
+}
+async function updateRepo(cacheDir, branch) {
+  const git = simpleGit(cacheDir);
+  await git.fetch(["--depth", "1", "origin", branch]);
+  await git.reset(["--hard", `origin/${branch}`]);
+  touchCache(cacheDir);
+  return { status: "updated", cacheDir };
+}
+async function forceUpdate(cacheDir, branch) {
+  return updateRepo(cacheDir, branch);
+}
+
+// src/lib/registry.ts
+import fs3 from "fs";
+import path4 from "path";
+import matter from "gray-matter";
+function scanSkills(repoDir) {
+  const skills = [];
+  walkDir(repoDir, repoDir, skills);
+  return skills.sort((a, b) => a.id.localeCompare(b.id));
+}
+function walkDir(baseDir, currentDir, results) {
+  let entries;
+  try {
+    entries = fs3.readdirSync(currentDir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    if (entry.isDirectory()) {
+      const relative = path4.relative(baseDir, path4.join(currentDir, entry.name));
+      const topLevel = relative.split(path4.sep)[0];
+      if (EXCLUDED_DIRS.includes(topLevel)) continue;
+      walkDir(baseDir, path4.join(currentDir, entry.name), results);
+    } else if (entry.name === "SKILL.md") {
+      const skill = parseSkillFile(baseDir, path4.join(currentDir, entry.name));
+      if (skill) results.push(skill);
+    }
+  }
+}
+function parseSkillFile(baseDir, filePath) {
+  try {
+    const raw = fs3.readFileSync(filePath, "utf-8");
+    const { data, content } = matter(raw);
+    const relativePath = path4.relative(baseDir, filePath);
+    const id = deriveSkillId(relativePath);
+    return {
+      id,
+      name: data.name || id,
+      description: data.description || extractFirstLine(content),
+      relativePath,
+      content
+    };
+  } catch {
+    return null;
+  }
+}
+function deriveSkillId(relativePath) {
+  const normalized = relativePath.split(path4.sep).join("/");
+  return normalized.replace(/\/SKILL\.md$/, "");
+}
+function extractFirstLine(content) {
+  const lines = content.trim().split("\n");
+  for (const line of lines) {
+    const stripped = line.replace(/^#+\s*/, "").trim();
+    if (stripped) return stripped.slice(0, 100);
+  }
+  return "";
+}
+function searchSkills(skills, query) {
+  if (!query || query.trim() === "") {
+    return skills;
+  }
+  const q = query.toLowerCase();
+  const matches = [];
+  for (const skill of skills) {
+    const priority = getMatchPriority(skill, q);
+    if (priority > 0) {
+      matches.push({ skill, priority });
+    }
+  }
+  matches.sort((a, b) => {
+    if (a.priority !== b.priority) return a.priority - b.priority;
+    return a.skill.id.localeCompare(b.skill.id);
+  });
+  return matches.map((m) => m.skill);
+}
+function getMatchPriority(skill, query) {
+  if (skill.id.toLowerCase().includes(query)) return 1;
+  if (skill.name.toLowerCase().includes(query)) return 2;
+  if (skill.description.toLowerCase().includes(query)) return 3;
+  if (skill.content.toLowerCase().includes(query)) return 4;
+  return 0;
+}
+function findSkillById(skills, id) {
+  return skills.find((s) => s.id === id);
+}
+
+// src/lib/installer.ts
+import fs4 from "fs";
+import path5 from "path";
+function installSkill(repoDir, skill, options = {}) {
+  const agent = options.agent || DEFAULT_AGENT;
+  const paths = AGENT_PATHS[agent];
+  const baseDir = options.global ? paths.global : paths.project;
+  const targetDir = path5.join(baseDir, skill.id);
+  const exists = fs4.existsSync(targetDir);
+  if (exists && !options.force) {
+    throw new Error(
+      `Skill "${skill.id}" already installed at ${targetDir}
+Use --force to overwrite.`
+    );
+  }
+  const sourceDir = path5.join(repoDir, path5.dirname(skill.relativePath));
+  copyDirSync(sourceDir, targetDir);
+  return { skillId: skill.id, targetDir, overwritten: exists };
+}
+function removeSkill(skillId, options = {}) {
+  const agent = options.agent || DEFAULT_AGENT;
+  const paths = AGENT_PATHS[agent];
+  const baseDir = options.global ? paths.global : paths.project;
+  const targetDir = path5.join(baseDir, skillId);
+  if (!fs4.existsSync(targetDir)) {
+    throw new Error(`Skill "${skillId}" is not installed at ${targetDir}`);
+  }
+  fs4.rmSync(targetDir, { recursive: true, force: true });
+  return targetDir;
+}
+function listInstalledSkills(options) {
+  const agent = options.agent || DEFAULT_AGENT;
+  const paths = AGENT_PATHS[agent];
+  const results = [];
+  const scanGlobal = options.global || !options.global && !options.project;
+  const scanProject = options.project || !options.global && !options.project;
+  if (scanGlobal) {
+    scanInstalled(paths.global, "global", results);
+  }
+  if (scanProject) {
+    scanInstalled(paths.project, "project", results);
+  }
+  return results.sort((a, b) => a.id.localeCompare(b.id));
+}
+function isSkillInstalled(skillId, agent) {
+  const a = agent || DEFAULT_AGENT;
+  const paths = AGENT_PATHS[a];
+  const globalDir = path5.join(paths.global, skillId);
+  const projectDir = path5.join(paths.project, skillId);
+  return fs4.existsSync(path5.join(globalDir, "SKILL.md")) || fs4.existsSync(path5.join(projectDir, "SKILL.md"));
+}
+function scanInstalled(baseDir, location, results) {
+  if (!fs4.existsSync(baseDir)) return;
+  const entries = fs4.readdirSync(baseDir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    const entryPath = path5.join(baseDir, entry.name);
+    if (fs4.existsSync(path5.join(entryPath, "SKILL.md"))) {
+      results.push({ id: entry.name, location, dir: entryPath });
+    } else {
+      const subEntries = safeReaddir(entryPath);
+      for (const sub of subEntries) {
+        if (!sub.isDirectory()) continue;
+        const subPath = path5.join(entryPath, sub.name);
+        if (fs4.existsSync(path5.join(subPath, "SKILL.md"))) {
+          results.push({ id: `${entry.name}/${sub.name}`, location, dir: subPath });
+        }
+      }
+    }
+  }
+}
+function safeReaddir(dir) {
+  try {
+    return fs4.readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+}
+function copyDirSync(src, dest) {
+  fs4.mkdirSync(dest, { recursive: true });
+  const entries = fs4.readdirSync(src, { withFileTypes: true });
+  for (const entry of entries) {
+    const srcPath = path5.join(src, entry.name);
+    const destPath = path5.join(dest, entry.name);
+    if (entry.isDirectory()) {
+      copyDirSync(srcPath, destPath);
+    } else {
+      fs4.copyFileSync(srcPath, destPath);
+    }
+  }
+}
+
+// src/commands/find.ts
+async function findCommand(query, options = {}) {
+  const spinner5 = p.spinner();
+  spinner5.start("Syncing skills registry...");
+  try {
+    const result = await syncCache({ noCache: options.noCache });
+    const statusText = result.status === "cached" ? "cached" : result.status;
+    spinner5.stop(`Syncing skills registry... done (${statusText})`);
+    const allSkills = scanSkills(result.cacheDir);
+    const matched = searchSkills(allSkills, query);
+    for (const skill of matched) {
+      skill.installed = isSkillInstalled(skill.id);
+    }
+    if (matched.length === 0) {
+      p.log.warn(query ? `No skills found matching "${query}"` : "No skills found");
+      return;
+    }
+    p.log.info("Available Skills (engineering/skills):");
+    p.log.message("");
+    for (const skill of matched) {
+      const tag = skill.installed ? "  [installed]" : "";
+      const desc = skill.description ? `
+    ${truncate(skill.description, 60)}` : "";
+      p.log.message(`  ${skill.id}${tag}${desc}`);
+    }
+    p.log.message("");
+    p.log.info(`${matched.length} skill${matched.length > 1 ? "s" : ""} found`);
+    p.log.message("  Install: npx addx-skills add <skill-id>");
+  } catch (err) {
+    spinner5.stop("Syncing skills registry... failed");
+    p.log.error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+}
+function truncate(str, maxLen) {
+  if (str.length <= maxLen) return str;
+  return str.slice(0, maxLen - 3) + "...";
+}
+
+// src/commands/add.ts
+import * as p2 from "@clack/prompts";
+async function addCommand(skillId, options = {}) {
+  const spinner5 = p2.spinner();
+  spinner5.start("Syncing skills registry...");
+  try {
+    const result = await syncCache({ noCache: options.noCache });
+    spinner5.stop("Syncing skills registry... done");
+    const allSkills = scanSkills(result.cacheDir);
+    const skill = findSkillById(allSkills, skillId);
+    if (!skill) {
+      p2.log.error(`Skill "${skillId}" not found`);
+      p2.log.info("Use `npx addx-skills find` to see available skills");
+      process.exit(1);
+      return;
+    }
+    const installResult = installSkill(result.cacheDir, skill, {
+      agent: options.agent,
+      global: options.global,
+      force: options.force
+    });
+    if (installResult.overwritten) {
+      p2.log.success(`Skill "${skillId}" updated at ${installResult.targetDir}`);
+    } else {
+      p2.log.success(`Skill "${skillId}" installed to ${installResult.targetDir}`);
+    }
+  } catch (err) {
+    spinner5.stop("Failed");
+    p2.log.error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+}
+
+// src/commands/list.ts
+import * as p3 from "@clack/prompts";
+async function listCommand(options = {}) {
+  const installed = listInstalledSkills({
+    agent: options.agent,
+    global: options.global,
+    project: options.project
+  });
+  if (installed.length === 0) {
+    p3.log.info("No skills installed");
+    p3.log.message("  Install: npx addx-skills add <skill-id>");
+    return;
+  }
+  p3.log.info("Installed Skills:");
+  p3.log.message("");
+  for (const skill of installed) {
+    const locationTag = skill.location === "project" ? "  [project]" : "  [global]";
+    p3.log.message(`  ${skill.id}${locationTag}`);
+    p3.log.message(`    ${skill.dir}`);
+  }
+  p3.log.message("");
+  p3.log.info(`${installed.length} skill${installed.length > 1 ? "s" : ""} installed`);
+}
+
+// src/commands/remove.ts
+import * as p4 from "@clack/prompts";
+async function removeCommand(skillId, options = {}) {
+  try {
+    const removedDir = removeSkill(skillId, {
+      agent: options.agent,
+      global: options.global
+    });
+    p4.log.success(`Skill "${skillId}" removed from ${removedDir}`);
+  } catch (err) {
+    p4.log.error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+}
+
+// src/commands/update.ts
+import * as p5 from "@clack/prompts";
+async function updateCommand(options = {}) {
+  const spinner5 = p5.spinner();
+  spinner5.start("Updating skills registry cache...");
+  try {
+    const result = await syncCache({ noCache: true });
+    spinner5.stop(`Cache ${result.status === "cloned" ? "initialized" : "updated"} successfully`);
+    if (options.cache) {
+      return;
+    }
+    const installed = listInstalledSkills({});
+    if (installed.length === 0) {
+      p5.log.info("No installed skills to update");
+      return;
+    }
+    const allSkills = scanSkills(result.cacheDir);
+    let updatedCount = 0;
+    for (const entry of installed) {
+      const skill = findSkillById(allSkills, entry.id);
+      if (!skill) {
+        p5.log.warn(`Skill "${entry.id}" not found in registry, skipping`);
+        continue;
+      }
+      installSkill(result.cacheDir, skill, {
+        force: true,
+        global: entry.location === "global"
+      });
+      updatedCount++;
+    }
+    p5.log.success(`${updatedCount} skill${updatedCount > 1 ? "s" : ""} updated`);
+  } catch (err) {
+    spinner5.stop("Update failed");
+    p5.log.error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+}
+
+// src/commands/check.ts
+import fs5 from "fs";
+import path6 from "path";
+import * as p6 from "@clack/prompts";
+async function checkCommand() {
+  const spinner5 = p6.spinner();
+  spinner5.start("Checking for updates...");
+  try {
+    const result = await syncCache({ noCache: true });
+    spinner5.stop("Checking for updates... done");
+    const installed = listInstalledSkills({});
+    if (installed.length === 0) {
+      p6.log.info("No installed skills to check");
+      return;
+    }
+    const allSkills = scanSkills(result.cacheDir);
+    let updatesAvailable = 0;
+    for (const entry of installed) {
+      const remoteSkill = findSkillById(allSkills, entry.id);
+      if (!remoteSkill) {
+        p6.log.warn(`  ${entry.id}  \u2014 not found in registry`);
+        continue;
+      }
+      const localContent = readLocalSkillContent(entry.dir);
+      const remoteDir = path6.join(result.cacheDir, path6.dirname(remoteSkill.relativePath));
+      const remoteContent = readSkillContent(remoteDir);
+      if (localContent !== remoteContent) {
+        p6.log.warn(`  ${entry.id}  \u2014 update available`);
+        updatesAvailable++;
+      } else {
+        p6.log.success(`  ${entry.id}  \u2014 up to date`);
+      }
+    }
+    p6.log.message("");
+    if (updatesAvailable > 0) {
+      p6.log.info(`${updatesAvailable} update${updatesAvailable > 1 ? "s" : ""} available`);
+      p6.log.message("  Run `npx addx-skills update` to update all");
+    } else {
+      p6.log.info("All skills are up to date");
+    }
+  } catch (err) {
+    spinner5.stop("Check failed");
+    p6.log.error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+}
+function readLocalSkillContent(dir) {
+  return readSkillContent(dir);
+}
+function readSkillContent(dir) {
+  const skillPath = path6.join(dir, "SKILL.md");
+  try {
+    return fs5.readFileSync(skillPath, "utf-8");
+  } catch {
+    return "";
+  }
+}
+
+// src/commands/config.ts
+import * as p7 from "@clack/prompts";
+async function configCommand(options = {}) {
+  const hasUpdates = options.repo || options.branch || options.cacheTTL;
+  if (hasUpdates) {
+    const updates = {};
+    if (options.repo) updates.repo = options.repo;
+    if (options.branch) updates.branch = options.branch;
+    if (options.cacheTTL) updates.cacheTTL = parseInt(options.cacheTTL, 10);
+    saveConfig(updates);
+    p7.log.success("Configuration updated");
+  }
+  const config = getEffectiveConfig();
+  p7.log.info("Current configuration:");
+  p7.log.message("");
+  p7.log.message(`  repo      ${config.repo}`);
+  p7.log.message(`            (${config.source.repo})`);
+  p7.log.message(`  branch    ${config.branch}`);
+  p7.log.message(`            (${config.source.branch})`);
+  p7.log.message(`  cacheTTL  ${config.cacheTTL}s`);
+  p7.log.message(`            (${config.source.cacheTTL})`);
+  p7.log.message("");
+  p7.log.message(`  Config file: ${config.configPath}`);
+}
+
+// src/cli.ts
+var VERSION = "1.0.0";
+var HELP_TEXT = `
+  addx-skills - Search and install Skills from private GitLab registry
+
+  Usage:
+    addx-skills <command> [options]
+
+  Commands:
+    find [query]        Search skills (list all if no query)
+    add <skill-id>      Install a skill to current project
+    list, ls            List installed skills
+    remove, rm <id>     Remove an installed skill
+    check               Check for skill updates
+    update              Update cache and installed skills
+    config              View/set configuration
+
+  Global Options:
+    --help, -h          Show help
+    --version, -v       Show version
+    --no-cache          Skip cache, force refresh from remote
+
+  Find Options:
+    --no-cache          Force refresh before search
+
+  Add Options:
+    -g, --global        Install globally instead of project-level
+    -a, --agent <type>  Target agent: cursor | claude-code | codex | antigravity (default: cursor)
+    --force             Overwrite if already installed
+
+  List Options:
+    --global            Show only global skills
+    --project           Show only project skills
+
+  Remove Options:
+    -g, --global        Remove from global instead of project-level
+    -a, --agent <type>  Target agent
+
+  Update Options:
+    --cache             Only update cache, skip installed skills
+
+  Config Options:
+    --repo <url>        Set custom repository URL
+    --branch <name>     Set branch name
+    --cache-ttl <sec>   Set cache TTL in seconds
+
+  Examples:
+    npx addx-skills find
+    npx addx-skills find "sql"
+    npx addx-skills add security/sql-injection
+    npx addx-skills add dev-standards-review -g
+    npx addx-skills ls
+    npx addx-skills rm security/sql-injection
+    npx addx-skills check
+    npx addx-skills update
+    npx addx-skills config --repo https://gitlab.example.com/team/skills.git
+`;
+var SHORT_FLAGS = {
+  g: "global",
+  a: "agent",
+  h: "help",
+  v: "version"
+};
+function parseArgs(argv) {
+  const args = argv.slice(2);
+  let command = "";
+  const positional = [];
+  const flags = {};
+  let i = 0;
+  while (i < args.length) {
+    const arg = args[i];
+    if (arg.startsWith("--")) {
+      const key = arg.slice(2);
+      const next = args[i + 1];
+      if (next && !next.startsWith("-")) {
+        flags[key] = next;
+        i += 2;
+      } else {
+        flags[key] = true;
+        i += 1;
+      }
+    } else if (arg.startsWith("-")) {
+      const shortKey = arg.slice(1);
+      const longKey = SHORT_FLAGS[shortKey] || shortKey;
+      const next = args[i + 1];
+      if (next && !next.startsWith("-") && longKey === "agent") {
+        flags[longKey] = next;
+        i += 2;
+      } else {
+        flags[longKey] = true;
+        i += 1;
+      }
+    } else if (!command) {
+      command = arg;
+      i += 1;
+    } else {
+      positional.push(arg);
+      i += 1;
+    }
+  }
+  return { command, positional, flags };
+}
+function validateAgent(value) {
+  if (!value || typeof value === "boolean") return void 0;
+  const valid = ["cursor", "claude-code", "codex", "antigravity"];
+  if (!valid.includes(value)) {
+    p8.log.error(`Invalid agent "${value}". Must be one of: ${valid.join(", ")}`);
+    process.exit(1);
+  }
+  return value;
+}
+async function main() {
+  const { command, positional, flags } = parseArgs(process.argv);
+  if (flags.version) {
+    console.log(VERSION);
+    return;
+  }
+  if (flags.help || command === "help" || command === "") {
+    console.log(HELP_TEXT);
+    return;
+  }
+  p8.intro("addx-skills");
+  switch (command) {
+    case "find": {
+      const query = positional[0];
+      await findCommand(query, {
+        noCache: flags["no-cache"] === true
+      });
+      break;
+    }
+    case "add": {
+      const skillId = positional[0];
+      if (!skillId) {
+        p8.log.error("Missing skill ID. Usage: addx-skills add <skill-id>");
+        process.exit(1);
+      }
+      await addCommand(skillId, {
+        agent: validateAgent(flags.agent),
+        global: flags.global === true,
+        force: flags.force === true,
+        noCache: flags["no-cache"] === true
+      });
+      break;
+    }
+    case "list":
+    case "ls": {
+      await listCommand({
+        agent: validateAgent(flags.agent),
+        global: flags.global === true,
+        project: flags.project === true
+      });
+      break;
+    }
+    case "remove":
+    case "rm": {
+      const skillId = positional[0];
+      if (!skillId) {
+        p8.log.error("Missing skill ID. Usage: addx-skills remove <skill-id>");
+        process.exit(1);
+      }
+      await removeCommand(skillId, {
+        agent: validateAgent(flags.agent),
+        global: flags.global === true
+      });
+      break;
+    }
+    case "check": {
+      await checkCommand();
+      break;
+    }
+    case "update": {
+      await updateCommand({
+        cache: flags.cache === true
+      });
+      break;
+    }
+    case "config": {
+      await configCommand({
+        repo: typeof flags.repo === "string" ? flags.repo : void 0,
+        branch: typeof flags.branch === "string" ? flags.branch : void 0,
+        cacheTTL: typeof flags["cache-ttl"] === "string" ? flags["cache-ttl"] : void 0
+      });
+      break;
+    }
+    default: {
+      p8.log.error(`Unknown command: ${command}`);
+      console.log(HELP_TEXT);
+      process.exit(1);
+    }
+  }
+  p8.outro("Done");
+}
+main().catch((err) => {
+  p8.log.error(err instanceof Error ? err.message : String(err));
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "addx-skills",
+  "version": "1.0.0",
+  "description": "Search and install AI Agent Skills from private GitLab registry",
+  "type": "module",
+  "bin": {
+    "addx-skills": "./dist/cli.js"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "start": "node dist/cli.js",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "skills",
+    "ai",
+    "agent",
+    "cursor",
+    "claude",
+    "codex",
+    "cli"
+  ],
+  "license": "MIT",
+  "engines": {
+    "node": ">=18"
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@clack/prompts": "^0.10.0",
+    "gray-matter": "^4.0.3",
+    "simple-git": "^3.27.0"
+  },
+  "devDependencies": {
+    "@types/node": "^25.3.1",
+    "tsup": "^8.4.0",
+    "typescript": "^5.7.0",
+    "vitest": "^3.0.0"
+  }
+}