skill-master 0.1.0

package/dist/cli.js

@@ -0,0 +1,1368 @@
+#!/usr/bin/env node
+
+// src/core/installer.ts
+import { join as join6 } from "path";
+import { existsSync as existsSync6 } from "fs";
+
+// src/core/git-source.ts
+import { execFile } from "child_process";
+import { promisify } from "util";
+import { existsSync as existsSync2 } from "fs";
+
+// src/utils/fs-helpers.ts
+import { mkdir, cp, readFile, writeFile, rename, symlink, lstat, rm } from "fs/promises";
+import { existsSync } from "fs";
+import { dirname, join } from "path";
+import { tmpdir } from "os";
+import { randomBytes } from "crypto";
+async function ensureDir(dir) {
+  await mkdir(dir, { recursive: true });
+}
+async function copyDir(src, dest) {
+  await ensureDir(dest);
+  await cp(src, dest, { recursive: true, force: true });
+}
+async function removePath(target) {
+  if (existsSync(target)) {
+    await rm(target, { recursive: true, force: true });
+  }
+}
+async function atomicWriteJson(filePath, data) {
+  await ensureDir(dirname(filePath));
+  const tmpPath = filePath + ".tmp";
+  await writeFile(tmpPath, JSON.stringify(data, null, 2) + "\n", "utf-8");
+  await rename(tmpPath, filePath);
+}
+async function readJsonSafe(filePath) {
+  try {
+    const content = await readFile(filePath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+async function readTextSafe(filePath) {
+  try {
+    return await readFile(filePath, "utf-8");
+  } catch {
+    return null;
+  }
+}
+async function writeText(filePath, content) {
+  await ensureDir(dirname(filePath));
+  await writeFile(filePath, content, "utf-8");
+}
+async function symlinkOrCopy(target, linkPath, forceCopy = false) {
+  await ensureDir(dirname(linkPath));
+  await removePath(linkPath);
+  if (forceCopy) {
+    await copyDir(target, linkPath);
+    return "copy";
+  }
+  try {
+    await symlink(target, linkPath, "dir");
+    return "symlink";
+  } catch {
+    await copyDir(target, linkPath);
+    return "copy";
+  }
+}
+async function isSymlink(path) {
+  try {
+    const stat = await lstat(path);
+    return stat.isSymbolicLink();
+  } catch {
+    return false;
+  }
+}
+function createTempDir() {
+  const id = randomBytes(8).toString("hex");
+  return join(tmpdir(), `skill-master-${id}`);
+}
+
+// src/utils/errors.ts
+var SkillManagerError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "SkillManagerError";
+  }
+};
+var SkillNotFoundError = class extends SkillManagerError {
+  constructor(skillName) {
+    super(`Skill "${skillName}" not found`);
+    this.name = "SkillNotFoundError";
+  }
+};
+var RegistryCorruptError = class extends SkillManagerError {
+  constructor(detail) {
+    super(`Registry is corrupted${detail ? ": " + detail : ""}`);
+    this.name = "RegistryCorruptError";
+  }
+};
+var GitCloneError = class extends SkillManagerError {
+  constructor(url, detail) {
+    super(`Failed to clone "${url}"${detail ? ": " + detail : ""}`);
+    this.name = "GitCloneError";
+  }
+};
+var SkillParseError = class extends SkillManagerError {
+  constructor(detail) {
+    super(`Failed to parse SKILL.md: ${detail}`);
+    this.name = "SkillParseError";
+  }
+};
+
+// src/utils/logger.ts
+import chalk from "chalk";
+var PREFIX = chalk.blue("skill-master");
+function info(msg) {
+  console.log(`${PREFIX} ${chalk.cyan("info")} ${msg}`);
+}
+function success(msg) {
+  console.log(`${PREFIX} ${chalk.green("\u2714")} ${msg}`);
+}
+function warn(msg) {
+  console.log(`${PREFIX} ${chalk.yellow("\u26A0")} ${msg}`);
+}
+function error(msg) {
+  console.error(`${PREFIX} ${chalk.red("\u2716")} ${msg}`);
+}
+function debug(msg) {
+  if (process.env.DEBUG) {
+    console.log(`${PREFIX} ${chalk.gray("debug")} ${msg}`);
+  }
+}
+function step(num, total, msg) {
+  const counter = chalk.gray(`[${num}/${total}]`);
+  console.log(`${PREFIX} ${counter} ${msg}`);
+}
+function blank() {
+  console.log();
+}
+function kv(key, value) {
+  console.log(`  ${chalk.gray(key + ":")} ${value}`);
+}
+function tableHeader(...cols) {
+  console.log(chalk.bold(cols.map((c) => c.padEnd(20)).join("")));
+  console.log(chalk.gray("\u2500".repeat(cols.length * 20)));
+}
+function tableRow(...cols) {
+  console.log(cols.map((c) => c.padEnd(20)).join(""));
+}
+
+// src/core/git-source.ts
+var execFileAsync = promisify(execFile);
+function isGitUrl(source) {
+  return source.startsWith("https://") || source.startsWith("http://") || source.startsWith("git@") || source.startsWith("git://") || source.includes("github.com/") || source.includes("gitlab.com/");
+}
+function normalizeGitUrl(source) {
+  if (source.startsWith("https://") || source.startsWith("http://") || source.startsWith("git@") || source.startsWith("git://")) {
+    if (source.startsWith("https://") && !source.endsWith(".git")) {
+      return source + ".git";
+    }
+    return source;
+  }
+  if (/^[a-zA-Z0-9_.-]+\/[a-zA-Z0-9_.-]+$/.test(source)) {
+    return `https://github.com/${source}.git`;
+  }
+  return source;
+}
+function parseGitUrl(url) {
+  const treeMatch = url.match(/github\.com\/([^/]+)\/([^/]+)\/tree\/(.+)/);
+  if (treeMatch) {
+    return {
+      owner: treeMatch[1],
+      repo: treeMatch[2].replace(/\.git$/, ""),
+      branch: treeMatch[3]
+    };
+  }
+  const match = url.match(/github\.com[/:]([^/]+)\/([^/.]+)/);
+  if (match) {
+    return { owner: match[1], repo: match[2] };
+  }
+  throw new GitCloneError(url, "Unable to parse GitHub URL");
+}
+async function cloneRepo(url, branch) {
+  const normalizedUrl = normalizeGitUrl(url);
+  const tempDir = createTempDir();
+  await ensureDir(tempDir);
+  const args = ["clone", "--depth", "1"];
+  if (branch) {
+    args.push("--branch", branch);
+  }
+  args.push(normalizedUrl, tempDir);
+  debug(`Cloning ${normalizedUrl} to ${tempDir}`);
+  try {
+    await execFileAsync("git", args, { timeout: 6e4 });
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    throw new GitCloneError(url, msg);
+  }
+  return tempDir;
+}
+
+// src/core/skill-parser.ts
+import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
+import { readdir } from "fs/promises";
+import { join as join2 } from "path";
+import { existsSync as existsSync3 } from "fs";
+var TOOL_CAPABILITY_MAP = {
+  "Bash": "shell",
+  "Read": "read_file",
+  "Write": "write_file",
+  "Edit": "edit_file",
+  "Glob": "find_file",
+  "Grep": "search_content",
+  "Task": "sub_task",
+  "WebFetch": "web_fetch",
+  "WebSearch": "web_search"
+};
+function parseSkillMd(content) {
+  const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/);
+  if (!match) {
+    throw new SkillParseError("No valid frontmatter block found");
+  }
+  const rawFrontmatter = match[1];
+  const body = match[2];
+  let frontmatter;
+  try {
+    frontmatter = parseYaml(rawFrontmatter);
+  } catch (err) {
+    throw new SkillParseError(`YAML parse error: ${err.message}`);
+  }
+  validateFrontmatter(frontmatter);
+  return { frontmatter, body, rawFrontmatter };
+}
+function validateFrontmatter(fm) {
+  if (!fm.name || typeof fm.name !== "string") {
+    throw new SkillParseError('Missing or invalid "name" field');
+  }
+  if (!fm.version || typeof fm.version !== "string") {
+    throw new SkillParseError('Missing or invalid "version" field');
+  }
+  if (!Array.isArray(fm["allowed-tools"]) || fm["allowed-tools"].length === 0) {
+    throw new SkillParseError('Missing or empty "allowed-tools" field');
+  }
+}
+function inferCapabilities(allowedTools) {
+  const caps = /* @__PURE__ */ new Set();
+  for (const tool of allowedTools) {
+    const cap = TOOL_CAPABILITY_MAP[tool];
+    if (cap) {
+      caps.add(cap);
+    }
+  }
+  return [...caps];
+}
+async function findSkillDirectory(dir) {
+  if (existsSync3(join2(dir, "SKILL.md"))) {
+    return dir;
+  }
+  const skillsRoot = join2(dir, ".claude", "skills");
+  if (!existsSync3(skillsRoot)) {
+    return null;
+  }
+  try {
+    const entries = await readdir(skillsRoot, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        const skillMdPath = join2(skillsRoot, entry.name, "SKILL.md");
+        if (existsSync3(skillMdPath)) {
+          return join2(skillsRoot, entry.name);
+        }
+      }
+    }
+  } catch {
+    return null;
+  }
+  return null;
+}
+async function readSkillMd(dir) {
+  const content = await readTextSafe(join2(dir, "SKILL.md"));
+  if (!content) return null;
+  return parseSkillMd(content);
+}
+function extractEnvKeys(envExampleContent) {
+  const keys = [];
+  for (const line of envExampleContent.split("\n")) {
+    const trimmed = line.trim();
+    if (trimmed && !trimmed.startsWith("#")) {
+      const match = trimmed.match(/^([A-Z_][A-Z0-9_]*)=/);
+      if (match) {
+        keys.push(match[1]);
+      }
+    }
+  }
+  return keys;
+}
+
+// src/core/env-manager.ts
+import { join as join4 } from "path";
+
+// src/utils/paths.ts
+import { homedir } from "os";
+import { join as join3 } from "path";
+var AGENTS_HOME = join3(homedir(), ".agents");
+var CONFIG_DIR = join3(AGENTS_HOME, "config");
+var SKILLS_DIR = join3(AGENTS_HOME, "skills");
+var REGISTRY_PATH = join3(AGENTS_HOME, "registry.json");
+function getSkillCanonicalPath(name) {
+  return join3(SKILLS_DIR, name);
+}
+function getSkillConfigPath(name) {
+  return join3(CONFIG_DIR, name);
+}
+var AGENT_SKILL_DIRS = {
+  "claude-code": ".claude/skills",
+  "opencode": ".opencode/skills",
+  "cursor": ".cursor/skills",
+  "cline": ".cline/skills",
+  "windsurf": ".windsurf/skills"
+};
+function getAgentSkillPath(cwd, agent, name) {
+  return join3(cwd, AGENT_SKILL_DIRS[agent], name);
+}
+
+// src/core/env-manager.ts
+function parseEnvFile(content) {
+  const result = {};
+  for (const line of content.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const eqIndex = trimmed.indexOf("=");
+    if (eqIndex === -1) continue;
+    const key = trimmed.slice(0, eqIndex).trim();
+    let value = trimmed.slice(eqIndex + 1).trim();
+    if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+      value = value.slice(1, -1);
+    }
+    result[key] = value;
+  }
+  return result;
+}
+function serializeEnv(data) {
+  return Object.entries(data).map(([key, value]) => `${key}=${value}`).join("\n") + "\n";
+}
+async function backupEnv(skillName, agentSkillDir) {
+  const locations = [
+    join4(getSkillConfigPath(skillName), ".env"),
+    ...agentSkillDir ? [join4(agentSkillDir, ".env")] : [],
+    join4(getSkillCanonicalPath(skillName), ".env")
+  ];
+  for (const loc of locations) {
+    const content = await readTextSafe(loc);
+    if (content) {
+      const data = parseEnvFile(content);
+      if (Object.keys(data).length > 0) {
+        debug(`Backed up .env from ${loc}`);
+        return data;
+      }
+    }
+  }
+  return null;
+}
+async function restoreEnv(skillName, envData, skillDir) {
+  const exampleContent = await readTextSafe(join4(skillDir, ".env.example"));
+  let finalContent;
+  if (exampleContent) {
+    finalContent = mergeEnv(envData, exampleContent);
+  } else {
+    finalContent = serializeEnv(envData);
+  }
+  const configEnvPath = join4(getSkillConfigPath(skillName), ".env");
+  await writeText(configEnvPath, finalContent);
+  const skillEnvPath = join4(skillDir, ".env");
+  await writeText(skillEnvPath, finalContent);
+  debug(`Restored .env to ${configEnvPath} and ${skillEnvPath}`);
+}
+function mergeEnv(existing, exampleContent) {
+  const lines = [];
+  const usedKeys = /* @__PURE__ */ new Set();
+  for (const [key, value] of Object.entries(existing)) {
+    lines.push(`${key}=${value}`);
+    usedKeys.add(key);
+  }
+  const exampleKeys = parseEnvFile(exampleContent);
+  const newKeys = Object.keys(exampleKeys).filter((k) => !usedKeys.has(k));
+  if (newKeys.length > 0) {
+    lines.push("");
+    lines.push("# New keys added by skill update (please configure):");
+    for (const key of newKeys) {
+      lines.push(`# ${key}=`);
+    }
+  }
+  return lines.join("\n") + "\n";
+}
+async function getEnvStatus(skillName, requiredKeys) {
+  if (requiredKeys.length === 0) return "configured";
+  const configEnvPath = join4(getSkillConfigPath(skillName), ".env");
+  const content = await readTextSafe(configEnvPath);
+  if (!content) return "missing";
+  const data = parseEnvFile(content);
+  const configuredKeys = Object.entries(data).filter(([, v]) => v && !v.includes("your_") && !v.includes("_here")).map(([k]) => k);
+  const allConfigured = requiredKeys.every((k) => configuredKeys.includes(k));
+  const someConfigured = requiredKeys.some((k) => configuredKeys.includes(k));
+  if (allConfigured) return "configured";
+  if (someConfigured) return "partial";
+  return "missing";
+}
+async function setEnvValue(skillName, key, value, skillDir) {
+  const configEnvPath = join4(getSkillConfigPath(skillName), ".env");
+  const content = await readTextSafe(configEnvPath);
+  const data = content ? parseEnvFile(content) : {};
+  data[key] = value;
+  const newContent = serializeEnv(data);
+  await writeText(configEnvPath, newContent);
+  if (skillDir) {
+    await writeText(join4(skillDir, ".env"), newContent);
+  }
+}
+function getEnvEditPath(skillName) {
+  return join4(getSkillConfigPath(skillName), ".env");
+}
+
+// src/core/registry.ts
+import { existsSync as existsSync4 } from "fs";
+function createEmptyRegistry() {
+  return { version: 1, skills: {} };
+}
+function validateRegistry(data) {
+  if (!data || typeof data !== "object") return false;
+  const reg = data;
+  return reg.version === 1 && typeof reg.skills === "object" && reg.skills !== null;
+}
+async function readRegistry() {
+  if (!existsSync4(REGISTRY_PATH)) {
+    return createEmptyRegistry();
+  }
+  const data = await readJsonSafe(REGISTRY_PATH);
+  if (!data) {
+    throw new RegistryCorruptError("Failed to parse registry.json");
+  }
+  if (!validateRegistry(data)) {
+    throw new RegistryCorruptError("Invalid registry structure");
+  }
+  return data;
+}
+async function updateRegistry(skillName, entry) {
+  const registry = await readRegistry();
+  registry.skills[skillName] = entry;
+  await atomicWriteJson(REGISTRY_PATH, registry);
+}
+async function removeFromRegistry(skillName) {
+  const registry = await readRegistry();
+  delete registry.skills[skillName];
+  await atomicWriteJson(REGISTRY_PATH, registry);
+}
+async function listRegistry() {
+  const registry = await readRegistry();
+  return registry.skills;
+}
+async function getRegistryEntry(skillName) {
+  const registry = await readRegistry();
+  return registry.skills[skillName] ?? null;
+}
+
+// src/platform/detector.ts
+import { existsSync as existsSync5 } from "fs";
+import { join as join5 } from "path";
+import { homedir as homedir2 } from "os";
+var PLATFORM_MARKERS = [
+  { dir: ".claude", platform: "claude-code" },
+  { dir: ".cursor", platform: "cursor" },
+  { dir: ".windsurf", platform: "windsurf" },
+  { dir: ".cline", platform: "cline" }
+];
+function detectPlatform(cwd) {
+  for (const { dir, platform } of PLATFORM_MARKERS) {
+    if (existsSync5(join5(cwd, dir))) {
+      return platform;
+    }
+  }
+  if (existsSync5(join5(homedir2(), ".config", "opencode"))) {
+    return "opencode";
+  }
+  return "claude-code";
+}
+
+// src/core/installer.ts
+var TOTAL_STEPS = 9;
+async function installSkill(options) {
+  const { source, cwd, copy = false, force = false } = options;
+  step(1, TOTAL_STEPS, "Fetching skill source...");
+  let sourceDir;
+  if (source.type === "git") {
+    sourceDir = await cloneRepo(source.url, source.branch);
+  } else if (source.type === "local") {
+    sourceDir = source.path;
+    if (!existsSync6(sourceDir)) {
+      throw new SkillNotFoundError(sourceDir);
+    }
+  } else {
+    throw new SkillParseError("Invalid source type");
+  }
+  step(2, TOTAL_STEPS, "Locating SKILL.md...");
+  const skillDir = await findSkillDirectory(sourceDir);
+  if (!skillDir) {
+    throw new SkillNotFoundError(`No SKILL.md found in ${sourceDir}`);
+  }
+  step(3, TOTAL_STEPS, "Parsing SKILL.md...");
+  const parsed = await readSkillMd(skillDir);
+  if (!parsed) {
+    throw new SkillParseError("Failed to read SKILL.md");
+  }
+  const skillName = parsed.frontmatter.name;
+  info(`Found skill: ${skillName} v${parsed.frontmatter.version}`);
+  step(4, TOTAL_STEPS, "Detecting agent platform...");
+  const agent = options.agent ?? detectPlatform(cwd);
+  info(`Target platform: ${agent}`);
+  step(5, TOTAL_STEPS, "Backing up .env...");
+  const agentSkillDir = getAgentSkillPath(cwd, agent, skillName);
+  const envBackup = await backupEnv(skillName, agentSkillDir);
+  if (envBackup) {
+    success(`Backed up ${Object.keys(envBackup).length} env key(s)`);
+  } else {
+    info("No existing .env found");
+  }
+  step(6, TOTAL_STEPS, "Installing to canonical path...");
+  const canonicalPath = getSkillCanonicalPath(skillName);
+  if (existsSync6(canonicalPath) && !force) {
+    info("Replacing existing installation");
+  }
+  await removePath(canonicalPath);
+  await copyDir(skillDir, canonicalPath);
+  success(`Installed to ${canonicalPath}`);
+  step(7, TOTAL_STEPS, "Restoring .env...");
+  if (envBackup) {
+    await restoreEnv(skillName, envBackup, canonicalPath);
+    success(".env restored successfully");
+  } else {
+    const examplePath = join6(canonicalPath, ".env.example");
+    if (existsSync6(examplePath)) {
+      warn("Found .env.example \u2014 run `skill-master env edit " + skillName + "` to configure");
+    }
+  }
+  step(8, TOTAL_STEPS, `Linking to ${agent} skills directory...`);
+  const agentPath = getAgentSkillPath(cwd, agent, skillName);
+  const linkType = await symlinkOrCopy(canonicalPath, agentPath, copy);
+  success(`${linkType === "symlink" ? "Symlinked" : "Copied"} to ${agentPath}`);
+  step(9, TOTAL_STEPS, "Updating registry...");
+  const capabilities = parsed.frontmatter.capabilities ?? inferCapabilities(parsed.frontmatter["allowed-tools"]);
+  const envExampleContent = await readTextSafe(join6(canonicalPath, ".env.example"));
+  const envKeys = envExampleContent ? extractEnvKeys(envExampleContent) : [];
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const entry = {
+    source: source.type === "git" ? source.url : source.path,
+    version: parsed.frontmatter.version,
+    installed_at: now,
+    updated_at: now,
+    agent,
+    env_keys: envKeys,
+    capabilities,
+    canonical_path: canonicalPath,
+    agent_path: agentPath
+  };
+  await updateRegistry(skillName, entry);
+  blank();
+  success(`Skill "${skillName}" installed successfully!`);
+}
+
+// src/commands/add.ts
+function parseAddFlags(args) {
+  const flags = {
+    global: false,
+    agent: [],
+    skill: [],
+    yes: false,
+    list: false,
+    all: false,
+    fullDepth: false,
+    copy: false,
+    force: false
+  };
+  let source = null;
+  let i = 0;
+  while (i < args.length) {
+    const arg = args[i];
+    if (arg.startsWith("--") && arg.includes("=")) {
+      const eqIdx = arg.indexOf("=");
+      const key = arg.slice(2, eqIdx);
+      const val = arg.slice(eqIdx + 1);
+      switch (key) {
+        case "agent":
+          flags.agent.push(val);
+          break;
+        case "skill":
+          flags.skill.push(val);
+          break;
+        default:
+          break;
+      }
+      i++;
+      continue;
+    }
+    switch (arg) {
+      case "-g":
+      case "--global":
+        flags.global = true;
+        i++;
+        break;
+      case "-a":
+      case "--agent":
+        i++;
+        while (i < args.length && !args[i].startsWith("-")) {
+          flags.agent.push(args[i]);
+          i++;
+        }
+        break;
+      case "-s":
+      case "--skill":
+        i++;
+        while (i < args.length && !args[i].startsWith("-")) {
+          flags.skill.push(args[i]);
+          i++;
+        }
+        break;
+      case "-y":
+      case "--yes":
+        flags.yes = true;
+        i++;
+        break;
+      case "-l":
+      case "--list":
+        flags.list = true;
+        i++;
+        break;
+      case "--all":
+        flags.all = true;
+        i++;
+        break;
+      case "--full-depth":
+        flags.fullDepth = true;
+        i++;
+        break;
+      case "--copy":
+        flags.copy = true;
+        i++;
+        break;
+      case "--force":
+        flags.force = true;
+        i++;
+        break;
+      default:
+        if (!arg.startsWith("-") && source === null) {
+          source = arg;
+        }
+        i++;
+        break;
+    }
+  }
+  if (flags.all) {
+    if (flags.skill.length === 0) flags.skill.push("*");
+    if (flags.agent.length === 0) flags.agent.push("*");
+    flags.yes = true;
+  }
+  return { source, flags };
+}
+async function add(args) {
+  if (args.length === 0) {
+    error("Usage: skill-master add <source> [options]");
+    console.log("");
+    console.log("Options:");
+    console.log("  -g, --global          Install globally (~/.agents/)");
+    console.log("  -a, --agent <agents>  Target agents (space-separated)");
+    console.log("  -s, --skill <skills>  Select skills (space-separated)");
+    console.log("  -y, --yes             Skip confirmations");
+    console.log("  -l, --list            List available skills without installing");
+    console.log("  --all                 Install all skills to all agents");
+    console.log("  --full-depth          Search all subdirectories");
+    console.log("  --copy                Copy instead of symlink");
+    console.log("  --force               Force reinstall");
+    process.exit(1);
+  }
+  const { source, flags } = parseAddFlags(args);
+  if (!source) {
+    error("No source specified. Provide a GitHub URL, owner/repo, or local path.");
+    process.exit(1);
+  }
+  const skillSource = isGitUrl(source) ? { type: "git", url: source } : { type: "local", path: source };
+  const cwd = process.cwd();
+  const agents = flags.agent.length > 0 ? flags.agent : [void 0];
+  try {
+    for (const agent of agents) {
+      await installSkill({
+        source: skillSource,
+        agent,
+        cwd,
+        copy: flags.copy,
+        force: flags.force,
+        yes: flags.yes
+      });
+    }
+  } catch (err) {
+    error(err.message);
+    process.exit(1);
+  }
+}
+
+// src/commands/update.ts
+async function update(args) {
+  if (args.length === 0) {
+    error("Usage: skill-master update <skill-name> [--force]");
+    process.exit(1);
+  }
+  const skillName = args[0];
+  const force = args.includes("--force");
+  try {
+    const entry = await getRegistryEntry(skillName);
+    if (!entry) {
+      throw new SkillNotFoundError(skillName);
+    }
+    info(`Updating skill: ${skillName}`);
+    info(`Source: ${entry.source}`);
+    const source = isGitUrl(entry.source) ? { type: "git", url: entry.source } : { type: "local", path: entry.source };
+    await installSkill({
+      source,
+      agent: entry.agent,
+      cwd: process.cwd(),
+      force: true
+    });
+    success(`Skill "${skillName}" updated successfully!`);
+  } catch (err) {
+    error(err.message);
+    process.exit(1);
+  }
+}
+
+// src/commands/remove.ts
+function parseRemoveFlags(args) {
+  const flags = {
+    global: false,
+    agent: [],
+    skill: [],
+    yes: false,
+    all: false,
+    purge: false
+  };
+  const names = [];
+  let i = 0;
+  while (i < args.length) {
+    const arg = args[i];
+    if (arg.startsWith("--") && arg.includes("=")) {
+      const eqIdx = arg.indexOf("=");
+      const key = arg.slice(2, eqIdx);
+      const val = arg.slice(eqIdx + 1);
+      switch (key) {
+        case "agent":
+          flags.agent.push(val);
+          break;
+        case "skill":
+          flags.skill.push(val);
+          break;
+        default:
+          break;
+      }
+      i++;
+      continue;
+    }
+    switch (arg) {
+      case "-g":
+      case "--global":
+        flags.global = true;
+        i++;
+        break;
+      case "-a":
+      case "--agent":
+        i++;
+        while (i < args.length && !args[i].startsWith("-")) {
+          flags.agent.push(args[i]);
+          i++;
+        }
+        break;
+      case "-s":
+      case "--skill":
+        i++;
+        while (i < args.length && !args[i].startsWith("-")) {
+          flags.skill.push(args[i]);
+          i++;
+        }
+        break;
+      case "-y":
+      case "--yes":
+        flags.yes = true;
+        i++;
+        break;
+      case "--all":
+        flags.all = true;
+        i++;
+        break;
+      case "--purge":
+        flags.purge = true;
+        i++;
+        break;
+      default:
+        if (!arg.startsWith("-")) {
+          names.push(arg);
+        }
+        i++;
+        break;
+    }
+  }
+  if (flags.all) {
+    flags.yes = true;
+  }
+  return { names, flags };
+}
+async function remove(args) {
+  if (args.length === 0) {
+    error("Usage: skill-master remove [skills...] [options]");
+    console.log("");
+    console.log("Options:");
+    console.log("  -g, --global          Remove from global (~/.agents/)");
+    console.log("  -a, --agent <agents>  Target agents (space-separated)");
+    console.log("  -s, --skill <skills>  Select skills (space-separated)");
+    console.log("  -y, --yes             Skip confirmations");
+    console.log("  --all                 Remove all skills");
+    console.log("  --purge               Also remove config data");
+    process.exit(1);
+  }
+  const { names, flags } = parseRemoveFlags(args);
+  let skillNames;
+  if (flags.all) {
+    const registry = await listRegistry();
+    skillNames = Object.keys(registry);
+  } else if (flags.skill.length > 0) {
+    skillNames = flags.skill;
+  } else {
+    skillNames = names;
+  }
+  if (skillNames.length === 0) {
+    error("No skills specified. Provide skill names or use --all.");
+    process.exit(1);
+  }
+  try {
+    for (const skillName of skillNames) {
+      const entry = await getRegistryEntry(skillName);
+      if (!entry) {
+        throw new SkillNotFoundError(skillName);
+      }
+      info(`Removing skill: ${skillName}`);
+      await removePath(entry.agent_path);
+      success(`Removed from ${entry.agent_path}`);
+      await removePath(entry.canonical_path);
+      success(`Removed from ${entry.canonical_path}`);
+      if (flags.purge) {
+        await removePath(getSkillConfigPath(skillName));
+        success("Purged config directory");
+      }
+      await removeFromRegistry(skillName);
+      success(`Skill "${skillName}" removed successfully!`);
+    }
+  } catch (err) {
+    error(err.message);
+    process.exit(1);
+  }
+}
+
+// src/commands/env.ts
+import { spawn } from "child_process";
+async function env(args) {
+  const subcommand = args[0];
+  if (!subcommand || subcommand === "list") {
+    await envList();
+  } else if (subcommand === "set") {
+    await envSet(args.slice(1));
+  } else if (subcommand === "edit") {
+    await envEdit(args.slice(1));
+  } else {
+    error("Usage: skill-master env <list|set|edit>");
+    process.exit(1);
+  }
+}
+async function envList() {
+  const skills = await listRegistry();
+  const entries = Object.entries(skills);
+  if (entries.length === 0) {
+    info("No skills installed");
+    return;
+  }
+  blank();
+  tableHeader("Skill", "Status", "Keys");
+  for (const [name, entry] of entries) {
+    const status = await getEnvStatus(name, entry.env_keys);
+    const statusIcon = status === "configured" ? "\u2713" : status === "partial" ? "\u26A0" : "\u2717";
+    tableRow(name, `${statusIcon} ${status}`, entry.env_keys.join(", "));
+  }
+  blank();
+}
+async function envSet(args) {
+  if (args.length < 2) {
+    error("Usage: skill-master env set <skill> KEY=VALUE");
+    process.exit(1);
+  }
+  const skillName = args[0];
+  const [key, value] = args[1].split("=");
+  if (!key || !value) {
+    error("Invalid format. Use: KEY=VALUE");
+    process.exit(1);
+  }
+  try {
+    const skillDir = getSkillCanonicalPath(skillName);
+    await setEnvValue(skillName, key, value, skillDir);
+    success(`Set ${key} for ${skillName}`);
+  } catch (err) {
+    error(err.message);
+    process.exit(1);
+  }
+}
+async function envEdit(args) {
+  if (args.length === 0) {
+    error("Usage: skill-master env edit <skill>");
+    process.exit(1);
+  }
+  const skillName = args[0];
+  const envPath = getEnvEditPath(skillName);
+  const editor = process.env.EDITOR || "vi";
+  info(`Opening ${envPath} with ${editor}...`);
+  const child = spawn(editor, [envPath], {
+    stdio: "inherit",
+    shell: true
+  });
+  child.on("exit", (code) => {
+    if (code === 0) {
+      success("Saved");
+    } else {
+      error("Editor exited with error");
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/list.ts
+function parseListFlags(args) {
+  const flags = {
+    global: false,
+    agent: []
+  };
+  let i = 0;
+  while (i < args.length) {
+    const arg = args[i];
+    if (arg.startsWith("--") && arg.includes("=")) {
+      const eqIdx = arg.indexOf("=");
+      const key = arg.slice(2, eqIdx);
+      const val = arg.slice(eqIdx + 1);
+      if (key === "agent") flags.agent.push(val);
+      i++;
+      continue;
+    }
+    switch (arg) {
+      case "-g":
+      case "--global":
+        flags.global = true;
+        i++;
+        break;
+      case "-a":
+      case "--agent":
+        i++;
+        while (i < args.length && !args[i].startsWith("-")) {
+          flags.agent.push(args[i]);
+          i++;
+        }
+        break;
+      default:
+        i++;
+        break;
+    }
+  }
+  return flags;
+}
+async function list(args = []) {
+  const flags = parseListFlags(args);
+  const skills = await listRegistry();
+  let entries = Object.entries(skills);
+  if (flags.agent.length > 0) {
+    entries = entries.filter(([, entry]) => flags.agent.includes(entry.agent));
+  }
+  if (entries.length === 0) {
+    info("No skills installed");
+    return;
+  }
+  blank();
+  tableHeader("Skill", "Version", "Platform", "Installed");
+  for (const [name, entry] of entries) {
+    const date = new Date(entry.installed_at).toLocaleDateString();
+    tableRow(name, entry.version, entry.agent, date);
+  }
+  blank();
+}
+
+// src/commands/info.ts
+async function info2(args) {
+  if (args.length === 0) {
+    error("Usage: skill-master info <skill-name>");
+    process.exit(1);
+  }
+  const skillName = args[0];
+  try {
+    const entry = await getRegistryEntry(skillName);
+    if (!entry) {
+      throw new SkillNotFoundError(skillName);
+    }
+    const envStatus = await getEnvStatus(skillName, entry.env_keys);
+    blank();
+    info(`Skill: ${skillName}`);
+    kv("Version", entry.version);
+    kv("Platform", entry.agent);
+    kv("Source", entry.source);
+    kv("Installed", new Date(entry.installed_at).toLocaleString());
+    kv("Updated", new Date(entry.updated_at).toLocaleString());
+    kv("Canonical Path", entry.canonical_path);
+    kv("Agent Path", entry.agent_path);
+    kv("Capabilities", entry.capabilities.join(", "));
+    kv("Env Keys", entry.env_keys.join(", ") || "none");
+    kv("Env Status", envStatus);
+    blank();
+  } catch (err) {
+    error(err.message);
+    process.exit(1);
+  }
+}
+
+// src/commands/doctor.ts
+import { existsSync as existsSync7 } from "fs";
+async function doctor() {
+  blank();
+  info("Running diagnostics...");
+  blank();
+  let issues = 0;
+  info("Checking directory structure...");
+  const dirs = [AGENTS_HOME, CONFIG_DIR, SKILLS_DIR];
+  for (const dir of dirs) {
+    if (existsSync7(dir)) {
+      success(`\u2713 ${dir}`);
+    } else {
+      warn(`\u2717 ${dir} (missing)`);
+      issues++;
+    }
+  }
+  blank();
+  info("Checking registry...");
+  if (existsSync7(REGISTRY_PATH)) {
+    success(`\u2713 ${REGISTRY_PATH}`);
+    try {
+      const skills = await listRegistry();
+      info(`  Found ${Object.keys(skills).length} skill(s)`);
+    } catch (err) {
+      error(`\u2717 Registry corrupted: ${err.message}`);
+      issues++;
+    }
+  } else {
+    info(`  No registry found (will be created on first install)`);
+  }
+  blank();
+  info("Checking installed skills...");
+  try {
+    const skills = await listRegistry();
+    for (const [name, entry] of Object.entries(skills)) {
+      info(`Skill: ${name}`);
+      if (existsSync7(entry.canonical_path)) {
+        success(`  \u2713 Canonical path exists`);
+      } else {
+        error(`  \u2717 Canonical path missing: ${entry.canonical_path}`);
+        issues++;
+      }
+      if (existsSync7(entry.agent_path)) {
+        const isLink = await isSymlink(entry.agent_path);
+        success(`  \u2713 Agent path exists (${isLink ? "symlink" : "copy"})`);
+      } else {
+        error(`  \u2717 Agent path missing: ${entry.agent_path}`);
+        issues++;
+      }
+      const envStatus = await getEnvStatus(name, entry.env_keys);
+      if (envStatus === "configured") {
+        success(`  \u2713 Environment configured`);
+      } else if (envStatus === "partial") {
+        warn(`  \u26A0 Environment partially configured`);
+      } else if (entry.env_keys.length > 0) {
+        warn(`  \u26A0 Environment not configured`);
+      }
+    }
+  } catch (err) {
+    error(`Failed to check skills: ${err.message}`);
+    issues++;
+  }
+  blank();
+  if (issues === 0) {
+    success("All checks passed!");
+  } else {
+    warn(`Found ${issues} issue(s)`);
+  }
+  blank();
+}
+
+// src/commands/find.ts
+async function find(args) {
+  const query = args.filter((a) => !a.startsWith("-")).join(" ").trim();
+  if (!query) {
+    console.log("Usage: skill-master find <query>");
+    console.log("");
+    console.log("Search for skills in the online registry.");
+    console.log("");
+    console.log("Examples:");
+    console.log("  skill-master find git");
+    console.log('  skill-master find "code review"');
+    process.exit(0);
+  }
+  info(`Searching for "${query}"...`);
+  try {
+    const url = `https://skills.sh/api/search?q=${encodeURIComponent(query)}`;
+    const response = await fetch(url, {
+      headers: { "Accept": "application/json" },
+      signal: AbortSignal.timeout(1e4)
+    });
+    if (!response.ok) {
+      error(`Search API returned ${response.status}: ${response.statusText}`);
+      process.exit(1);
+    }
+    const data = await response.json();
+    if (!Array.isArray(data) || data.length === 0) {
+      info("No skills found matching your query.");
+      return;
+    }
+    blank();
+    tableHeader("Name", "Source", "Installs");
+    for (const item of data) {
+      tableRow(
+        item.name ?? "\u2014",
+        item.source ?? "\u2014",
+        String(item.installs ?? 0)
+      );
+    }
+    blank();
+  } catch (err) {
+    if (err.name === "TimeoutError") {
+      error("Search request timed out. Please try again.");
+    } else {
+      error(`Search failed: ${err.message}`);
+    }
+    process.exit(1);
+  }
+}
+
+// src/commands/init.ts
+import { existsSync as existsSync8 } from "fs";
+import { join as join7, basename } from "path";
+var SKILL_MD_TEMPLATE = `---
+name: {{NAME}}
+version: 0.1.0
+author: ""
+description: ""
+allowed-tools:
+  - Read
+  - Edit
+  - Write
+  - Bash
+  - Glob
+  - Grep
+user-invocable: true
+---
+
+# {{NAME}}
+
+<!-- Describe what this skill does -->
+`;
+async function init(args) {
+  const nameArg = args.filter((a) => !a.startsWith("-"))[0];
+  const cwd = process.cwd();
+  let targetDir;
+  let skillName;
+  if (nameArg) {
+    targetDir = join7(cwd, nameArg);
+    skillName = nameArg;
+  } else {
+    targetDir = cwd;
+    skillName = basename(cwd);
+  }
+  const skillMdPath = join7(targetDir, "SKILL.md");
+  if (existsSync8(skillMdPath)) {
+    error(`SKILL.md already exists at ${skillMdPath}`);
+    process.exit(1);
+  }
+  await ensureDir(targetDir);
+  const content = SKILL_MD_TEMPLATE.replace(/\{\{NAME\}\}/g, skillName);
+  await writeText(skillMdPath, content);
+  success(`Created ${skillMdPath}`);
+  info(`Edit the file to configure your skill.`);
+}
+
+// src/commands/check.ts
+import { execFile as execFile2 } from "child_process";
+import { promisify as promisify2 } from "util";
+var execFileAsync2 = promisify2(execFile2);
+async function check(_args) {
+  const skills = await listRegistry();
+  const entries = Object.entries(skills);
+  if (entries.length === 0) {
+    info("No skills installed");
+    return;
+  }
+  info("Checking for updates...");
+  blank();
+  let updatable = 0;
+  for (const [name, entry] of entries) {
+    if (!isGitUrl(entry.source)) {
+      info(`${name}: local source \u2014 skipped`);
+      continue;
+    }
+    try {
+      const remoteHead = await getRemoteHead(entry.source);
+      if (!remoteHead) {
+        warn(`${name}: unable to query remote`);
+        continue;
+      }
+      const isUpToDate = entry.version === remoteHead.slice(0, entry.version.length);
+      if (isUpToDate) {
+        success(`${name}: up to date (${entry.version})`);
+      } else {
+        warn(`${name}: update available (${entry.version} \u2192 ${remoteHead.slice(0, 7)})`);
+        updatable++;
+      }
+    } catch {
+      warn(`${name}: failed to check remote`);
+    }
+  }
+  blank();
+  if (updatable === 0) {
+    success("All skills are up to date!");
+  } else {
+    info(`${updatable} skill(s) can be updated. Run "skill-master update <name>" to update.`);
+  }
+}
+async function getRemoteHead(source) {
+  try {
+    const { owner, repo } = parseGitUrl(source);
+    const url = `https://github.com/${owner}/${repo}.git`;
+    const { stdout } = await execFileAsync2("git", ["ls-remote", url, "HEAD"], {
+      timeout: 15e3
+    });
+    const match = stdout.trim().split(/\s+/)[0];
+    return match || null;
+  } catch {
+    return null;
+  }
+}
+
+// src/cli.ts
+var VERSION = "0.1.0";
+var HELP = `
+skill-master v${VERSION}
+
+Usage:
+  skill-master add <source> [options]     Install skills (aliases: install, a, i)
+  skill-master remove [skills...] [opts]  Remove skills (aliases: rm, r)
+  skill-master list [options]             List installed skills (alias: ls)
+  skill-master find [query]               Search for skills (aliases: search, f, s)
+  skill-master update [skill]             Update skills (alias: upgrade)
+  skill-master init [name]                Create a new skill template
+  skill-master check                      Check for skill updates
+  skill-master env <list|set|edit>        Manage environment variables
+  skill-master info <skill-name>          Show skill details
+  skill-master doctor                     Run diagnostics
+
+Add Options:
+  -g, --global          Install globally (~/.agents/)
+  -a, --agent <agents>  Target agents (space-separated)
+  -s, --skill <skills>  Select skills (space-separated)
+  -y, --yes             Skip confirmations
+  -l, --list            List available skills without installing
+  --all                 Install all skills to all agents
+  --full-depth          Search all subdirectories
+  --copy                Copy instead of symlink
+  --force               Force reinstall
+
+Examples:
+  skill-master add owner/repo
+  skill-master add https://github.com/user/skill -a claude-code cursor -y
+  skill-master add ./local-skill --agent=cursor --copy
+  skill-master remove my-skill --purge
+  skill-master find "code review"
+  skill-master init my-new-skill
+  skill-master check
+`;
+async function main() {
+  const args = process.argv.slice(2);
+  if (args.length === 0 || args[0] === "--help" || args[0] === "-h") {
+    console.log(HELP);
+    process.exit(0);
+  }
+  if (args[0] === "--version" || args[0] === "-v") {
+    console.log(VERSION);
+    process.exit(0);
+  }
+  const command = args[0];
+  const commandArgs = args.slice(1);
+  try {
+    switch (command) {
+      // add (primary) with aliases: install, a, i
+      case "add":
+      case "a":
+      case "install":
+      case "i":
+        await add(commandArgs);
+        break;
+      // remove with aliases: rm, r
+      case "remove":
+      case "rm":
+      case "r":
+        await remove(commandArgs);
+        break;
+      // list with alias: ls
+      case "list":
+      case "ls":
+        await list(commandArgs);
+        break;
+      // find with aliases: search, f, s
+      case "find":
+      case "search":
+      case "f":
+      case "s":
+        await find(commandArgs);
+        break;
+      // update with alias: upgrade
+      case "update":
+      case "upgrade":
+        await update(commandArgs);
+        break;
+      // init
+      case "init":
+        await init(commandArgs);
+        break;
+      // check
+      case "check":
+        await check(commandArgs);
+        break;
+      // env, info, doctor — skill-master extensions
+      case "env":
+        await env(commandArgs);
+        break;
+      case "info":
+        await info2(commandArgs);
+        break;
+      case "doctor":
+        await doctor();
+        break;
+      default:
+        error(`Unknown command: ${command}`);
+        console.log(HELP);
+        process.exit(1);
+    }
+  } catch (err) {
+    error(err.message);
+    if (process.env.DEBUG) {
+      console.error(err);
+    }
+    process.exit(1);
+  }
+}
+main();
+//# sourceMappingURL=cli.js.map