askill-cli 0.1.0

package/dist/cli.mjs

@@ -0,0 +1,2816 @@
+#!/usr/bin/env node
+
+// src/constants.ts
+import { homedir } from "os";
+import { join } from "path";
+import { existsSync } from "fs";
+var VERSION = "0.1.0";
+var API_BASE_URL = "https://askill.sh/api/v1";
+var RESET = "\x1B[0m";
+var BOLD = "\x1B[1m";
+var DIM = "\x1B[2m";
+var CYAN = "\x1B[36m";
+var GREEN = "\x1B[32m";
+var YELLOW = "\x1B[33m";
+var RED = "\x1B[31m";
+var home = homedir();
+var configHome = process.env.XDG_CONFIG_HOME || join(home, ".config");
+var codexHome = process.env.CODEX_HOME?.trim() || join(home, ".codex");
+var claudeHome = process.env.CLAUDE_CONFIG_DIR?.trim() || join(home, ".claude");
+var agents = {
+  // === Popular Agents ===
+  "claude-code": {
+    name: "claude-code",
+    displayName: "Claude Code",
+    skillsDir: ".claude/skills",
+    globalSkillsDir: join(claudeHome, "skills"),
+    detectInstalled: async () => existsSync(claudeHome)
+  },
+  cursor: {
+    name: "cursor",
+    displayName: "Cursor",
+    skillsDir: ".cursor/skills",
+    globalSkillsDir: join(home, ".cursor/skills"),
+    detectInstalled: async () => existsSync(join(home, ".cursor"))
+  },
+  windsurf: {
+    name: "windsurf",
+    displayName: "Windsurf",
+    skillsDir: ".windsurf/skills",
+    globalSkillsDir: join(home, ".codeium/windsurf/skills"),
+    detectInstalled: async () => existsSync(join(home, ".codeium/windsurf"))
+  },
+  opencode: {
+    name: "opencode",
+    displayName: "OpenCode",
+    skillsDir: ".opencode/skills",
+    globalSkillsDir: join(configHome, "opencode/skills"),
+    detectInstalled: async () => existsSync(join(configHome, "opencode")) || existsSync(join(claudeHome, "skills"))
+  },
+  codex: {
+    name: "codex",
+    displayName: "Codex",
+    skillsDir: ".codex/skills",
+    globalSkillsDir: join(codexHome, "skills"),
+    detectInstalled: async () => existsSync(codexHome) || existsSync("/etc/codex")
+  },
+  cline: {
+    name: "cline",
+    displayName: "Cline",
+    skillsDir: ".cline/skills",
+    globalSkillsDir: join(home, ".cline/skills"),
+    detectInstalled: async () => existsSync(join(home, ".cline"))
+  },
+  "gemini-cli": {
+    name: "gemini-cli",
+    displayName: "Gemini CLI",
+    skillsDir: ".gemini/skills",
+    globalSkillsDir: join(home, ".gemini/skills"),
+    detectInstalled: async () => existsSync(join(home, ".gemini"))
+  },
+  goose: {
+    name: "goose",
+    displayName: "Goose",
+    skillsDir: ".goose/skills",
+    globalSkillsDir: join(configHome, "goose/skills"),
+    detectInstalled: async () => existsSync(join(configHome, "goose"))
+  },
+  amp: {
+    name: "amp",
+    displayName: "Amp",
+    skillsDir: ".agents/skills",
+    globalSkillsDir: join(configHome, "agents/skills"),
+    detectInstalled: async () => existsSync(join(configHome, "amp"))
+  },
+  roo: {
+    name: "roo",
+    displayName: "Roo Code",
+    skillsDir: ".roo/skills",
+    globalSkillsDir: join(home, ".roo/skills"),
+    detectInstalled: async () => existsSync(join(home, ".roo"))
+  },
+  // === Additional Agents ===
+  antigravity: {
+    name: "antigravity",
+    displayName: "Antigravity",
+    skillsDir: ".agent/skills",
+    globalSkillsDir: join(home, ".gemini/antigravity/global_skills"),
+    detectInstalled: async () => existsSync(join(process.cwd(), ".agent")) || existsSync(join(home, ".gemini/antigravity"))
+  },
+  augment: {
+    name: "augment",
+    displayName: "Augment",
+    skillsDir: ".augment/rules",
+    globalSkillsDir: join(home, ".augment/rules"),
+    detectInstalled: async () => existsSync(join(home, ".augment"))
+  },
+  codebuddy: {
+    name: "codebuddy",
+    displayName: "CodeBuddy",
+    skillsDir: ".codebuddy/skills",
+    globalSkillsDir: join(home, ".codebuddy/skills"),
+    detectInstalled: async () => existsSync(join(process.cwd(), ".codebuddy")) || existsSync(join(home, ".codebuddy"))
+  },
+  "command-code": {
+    name: "command-code",
+    displayName: "Command Code",
+    skillsDir: ".commandcode/skills",
+    globalSkillsDir: join(home, ".commandcode/skills"),
+    detectInstalled: async () => existsSync(join(home, ".commandcode"))
+  },
+  continue: {
+    name: "continue",
+    displayName: "Continue",
+    skillsDir: ".continue/skills",
+    globalSkillsDir: join(home, ".continue/skills"),
+    detectInstalled: async () => existsSync(join(process.cwd(), ".continue")) || existsSync(join(home, ".continue"))
+  },
+  crush: {
+    name: "crush",
+    displayName: "Crush",
+    skillsDir: ".crush/skills",
+    globalSkillsDir: join(home, ".config/crush/skills"),
+    detectInstalled: async () => existsSync(join(home, ".config/crush"))
+  },
+  droid: {
+    name: "droid",
+    displayName: "Droid",
+    skillsDir: ".factory/skills",
+    globalSkillsDir: join(home, ".factory/skills"),
+    detectInstalled: async () => existsSync(join(home, ".factory"))
+  },
+  "github-copilot": {
+    name: "github-copilot",
+    displayName: "GitHub Copilot",
+    skillsDir: ".github/skills",
+    globalSkillsDir: join(home, ".copilot/skills"),
+    detectInstalled: async () => existsSync(join(process.cwd(), ".github")) || existsSync(join(home, ".copilot"))
+  },
+  junie: {
+    name: "junie",
+    displayName: "Junie",
+    skillsDir: ".junie/skills",
+    globalSkillsDir: join(home, ".junie/skills"),
+    detectInstalled: async () => existsSync(join(home, ".junie"))
+  },
+  "iflow-cli": {
+    name: "iflow-cli",
+    displayName: "iFlow CLI",
+    skillsDir: ".iflow/skills",
+    globalSkillsDir: join(home, ".iflow/skills"),
+    detectInstalled: async () => existsSync(join(home, ".iflow"))
+  },
+  kilo: {
+    name: "kilo",
+    displayName: "Kilo Code",
+    skillsDir: ".kilocode/skills",
+    globalSkillsDir: join(home, ".kilocode/skills"),
+    detectInstalled: async () => existsSync(join(home, ".kilocode"))
+  },
+  "kimi-cli": {
+    name: "kimi-cli",
+    displayName: "Kimi Code CLI",
+    skillsDir: ".agents/skills",
+    globalSkillsDir: join(home, ".config/agents/skills"),
+    detectInstalled: async () => existsSync(join(home, ".kimi"))
+  },
+  "kiro-cli": {
+    name: "kiro-cli",
+    displayName: "Kiro CLI",
+    skillsDir: ".kiro/skills",
+    globalSkillsDir: join(home, ".kiro/skills"),
+    detectInstalled: async () => existsSync(join(home, ".kiro"))
+  },
+  kode: {
+    name: "kode",
+    displayName: "Kode",
+    skillsDir: ".kode/skills",
+    globalSkillsDir: join(home, ".kode/skills"),
+    detectInstalled: async () => existsSync(join(home, ".kode"))
+  },
+  mcpjam: {
+    name: "mcpjam",
+    displayName: "MCPJam",
+    skillsDir: ".mcpjam/skills",
+    globalSkillsDir: join(home, ".mcpjam/skills"),
+    detectInstalled: async () => existsSync(join(home, ".mcpjam"))
+  },
+  "mistral-vibe": {
+    name: "mistral-vibe",
+    displayName: "Mistral Vibe",
+    skillsDir: ".vibe/skills",
+    globalSkillsDir: join(home, ".vibe/skills"),
+    detectInstalled: async () => existsSync(join(home, ".vibe"))
+  },
+  mux: {
+    name: "mux",
+    displayName: "Mux",
+    skillsDir: ".mux/skills",
+    globalSkillsDir: join(home, ".mux/skills"),
+    detectInstalled: async () => existsSync(join(home, ".mux"))
+  },
+  openclaw: {
+    name: "openclaw",
+    displayName: "OpenClaw",
+    skillsDir: "skills",
+    globalSkillsDir: existsSync(join(home, ".openclaw")) ? join(home, ".openclaw/skills") : existsSync(join(home, ".clawdbot")) ? join(home, ".clawdbot/skills") : join(home, ".moltbot/skills"),
+    detectInstalled: async () => existsSync(join(home, ".openclaw")) || existsSync(join(home, ".clawdbot")) || existsSync(join(home, ".moltbot"))
+  },
+  openclaude: {
+    name: "openclaude",
+    displayName: "OpenClaude IDE",
+    skillsDir: ".openclaude/skills",
+    globalSkillsDir: join(home, ".openclaude/skills"),
+    detectInstalled: async () => existsSync(join(home, ".openclaude")) || existsSync(join(process.cwd(), ".openclaude"))
+  },
+  openhands: {
+    name: "openhands",
+    displayName: "OpenHands",
+    skillsDir: ".openhands/skills",
+    globalSkillsDir: join(home, ".openhands/skills"),
+    detectInstalled: async () => existsSync(join(home, ".openhands"))
+  },
+  pi: {
+    name: "pi",
+    displayName: "Pi",
+    skillsDir: ".pi/skills",
+    globalSkillsDir: join(home, ".pi/agent/skills"),
+    detectInstalled: async () => existsSync(join(home, ".pi/agent"))
+  },
+  qoder: {
+    name: "qoder",
+    displayName: "Qoder",
+    skillsDir: ".qoder/skills",
+    globalSkillsDir: join(home, ".qoder/skills"),
+    detectInstalled: async () => existsSync(join(home, ".qoder"))
+  },
+  "qwen-code": {
+    name: "qwen-code",
+    displayName: "Qwen Code",
+    skillsDir: ".qwen/skills",
+    globalSkillsDir: join(home, ".qwen/skills"),
+    detectInstalled: async () => existsSync(join(home, ".qwen"))
+  },
+  replit: {
+    name: "replit",
+    displayName: "Replit",
+    skillsDir: ".agent/skills",
+    globalSkillsDir: void 0,
+    // No global support
+    detectInstalled: async () => existsSync(join(process.cwd(), ".agent"))
+  },
+  trae: {
+    name: "trae",
+    displayName: "Trae",
+    skillsDir: ".trae/skills",
+    globalSkillsDir: join(home, ".trae/skills"),
+    detectInstalled: async () => existsSync(join(home, ".trae"))
+  },
+  "trae-cn": {
+    name: "trae-cn",
+    displayName: "Trae CN",
+    skillsDir: ".trae/skills",
+    globalSkillsDir: join(home, ".trae-cn/skills"),
+    detectInstalled: async () => existsSync(join(home, ".trae-cn"))
+  },
+  zencoder: {
+    name: "zencoder",
+    displayName: "Zencoder",
+    skillsDir: ".zencoder/skills",
+    globalSkillsDir: join(home, ".zencoder/skills"),
+    detectInstalled: async () => existsSync(join(home, ".zencoder"))
+  },
+  neovate: {
+    name: "neovate",
+    displayName: "Neovate",
+    skillsDir: ".neovate/skills",
+    globalSkillsDir: join(home, ".neovate/skills"),
+    detectInstalled: async () => existsSync(join(home, ".neovate"))
+  },
+  pochi: {
+    name: "pochi",
+    displayName: "Pochi",
+    skillsDir: ".pochi/skills",
+    globalSkillsDir: join(home, ".pochi/skills"),
+    detectInstalled: async () => existsSync(join(home, ".pochi"))
+  },
+  adal: {
+    name: "adal",
+    displayName: "AdaL",
+    skillsDir: ".adal/skills",
+    globalSkillsDir: join(home, ".adal/skills"),
+    detectInstalled: async () => existsSync(join(home, ".adal"))
+  }
+};
+var AGENTS_DIR = ".agents";
+var SKILLS_SUBDIR = "skills";
+
+// src/api.ts
+var APIClient = class {
+  baseUrl;
+  constructor(baseUrl = API_BASE_URL) {
+    this.baseUrl = baseUrl;
+  }
+  async fetch(path, options) {
+    const url = `${this.baseUrl}${path}`;
+    const response = await fetch(url, {
+      ...options,
+      headers: {
+        "Content-Type": "application/json",
+        "User-Agent": "askill-cli",
+        ...options?.headers
+      }
+    });
+    if (!response.ok) {
+      const error = await response.json().catch(() => ({}));
+      throw new APIError(
+        response.status,
+        error.error?.code || "UNKNOWN_ERROR",
+        error.error?.message || `HTTP ${response.status}`
+      );
+    }
+    return response.json();
+  }
+  /**
+   * List skills with pagination and filtering
+   */
+  async listSkills(options = {}) {
+    const params = new URLSearchParams();
+    if (options.page) params.set("page", String(options.page));
+    if (options.limit) params.set("limit", String(options.limit));
+    if (options.q) params.set("q", options.q);
+    if (options.tag) params.set("tag", options.tag);
+    if (options.owner) params.set("owner", options.owner);
+    if (options.repo) params.set("repo", options.repo);
+    if (options.sort) params.set("sort", options.sort);
+    if (options.order) params.set("order", options.order);
+    const query = params.toString();
+    return this.fetch(`/skills${query ? `?${query}` : ""}`);
+  }
+  /**
+   * Get all skills in a repository
+   */
+  async getRepoSkills(owner, repo) {
+    return this.fetch(`/repos/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}/skills`);
+  }
+  /**
+   * Get a single skill by slug
+   * 
+   * Supported formats:
+   * - ID: "123"
+   * - Short name: "extract-errors" 
+   * - Owner/repo@name: "facebook/react@extract-errors"
+   * - Full path: "facebook/react/scripts/error-codes"
+   */
+  async getSkill(slug) {
+    return this.fetch(`/skills/${encodeURIComponent(slug)}`);
+  }
+  /**
+   * Get the raw SKILL.md content
+   */
+  async getSkillRaw(slug) {
+    const url = `${this.baseUrl}/skills/${encodeURIComponent(slug)}/raw`;
+    const response = await fetch(url, {
+      headers: { "User-Agent": "askill-cli" }
+    });
+    if (!response.ok) {
+      const error = await response.json().catch(() => ({}));
+      throw new APIError(
+        response.status,
+        error.error?.code || "NOT_FOUND",
+        error.error?.message || "Skill not found"
+      );
+    }
+    return response.text();
+  }
+  /**
+   * Search for skills (uses listSkills with q parameter)
+   */
+  async search(q, limit = 10) {
+    return this.listSkills({ q, limit });
+  }
+  /**
+   * Check for CLI updates
+   */
+  async checkCLIVersion() {
+    return this.fetch("/cli/version");
+  }
+};
+var APIError = class extends Error {
+  constructor(status, code, message) {
+    super(message);
+    this.status = status;
+    this.code = code;
+    this.name = "APIError";
+  }
+};
+var api = new APIClient();
+
+// src/installer.ts
+import { mkdir, writeFile, symlink, lstat, rm, readlink, access, readdir, cp } from "fs/promises";
+import { join as join2, dirname, relative, resolve, sep, normalize } from "path";
+import { homedir as homedir2, platform } from "os";
+var EXCLUDE_FILES = /* @__PURE__ */ new Set(["README.md", "metadata.json"]);
+var EXCLUDE_DIRS = /* @__PURE__ */ new Set([".git", "node_modules", "__pycache__", "dist", "build"]);
+function sanitizeName(name) {
+  const sanitized = name.toLowerCase().replace(/[^a-z0-9._]+/g, "-").replace(/^[.\-]+|[.\-]+$/g, "");
+  return sanitized.substring(0, 255) || "unnamed-skill";
+}
+function isPathSafe(basePath, targetPath) {
+  const normalizedBase = normalize(resolve(basePath));
+  const normalizedTarget = normalize(resolve(targetPath));
+  return normalizedTarget.startsWith(normalizedBase + sep) || normalizedTarget === normalizedBase;
+}
+function getCanonicalSkillsDir(global, cwd) {
+  const baseDir = global ? homedir2() : cwd || process.cwd();
+  return join2(baseDir, AGENTS_DIR, SKILLS_SUBDIR);
+}
+async function createSymlink(target, linkPath) {
+  try {
+    const resolvedTarget = resolve(target);
+    const resolvedLinkPath = resolve(linkPath);
+    if (resolvedTarget === resolvedLinkPath) {
+      return true;
+    }
+    try {
+      const stats = await lstat(linkPath);
+      if (stats.isSymbolicLink()) {
+        const existingTarget = await readlink(linkPath);
+        const resolvedExisting = resolve(dirname(linkPath), existingTarget);
+        if (resolvedExisting === resolvedTarget) {
+          return true;
+        }
+        await rm(linkPath);
+      } else {
+        await rm(linkPath, { recursive: true });
+      }
+    } catch (err) {
+      if (err.code === "ELOOP") {
+        await rm(linkPath, { force: true }).catch(() => {
+        });
+      }
+    }
+    const linkDir = dirname(linkPath);
+    await mkdir(linkDir, { recursive: true });
+    const relativePath = relative(linkDir, target);
+    const symlinkType = platform() === "win32" ? "junction" : void 0;
+    await symlink(relativePath, linkPath, symlinkType);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function cleanAndCreateDirectory(path) {
+  try {
+    await rm(path, { recursive: true, force: true });
+  } catch {
+  }
+  await mkdir(path, { recursive: true });
+}
+async function copySkillDirectory(src, dest) {
+  await mkdir(dest, { recursive: true });
+  const entries = await readdir(src, { withFileTypes: true });
+  await Promise.all(
+    entries.filter((entry) => {
+      if (entry.name.startsWith("_")) return false;
+      if (entry.isDirectory() && EXCLUDE_DIRS.has(entry.name)) return false;
+      if (!entry.isDirectory() && EXCLUDE_FILES.has(entry.name)) return false;
+      return true;
+    }).map(async (entry) => {
+      const srcPath = join2(src, entry.name);
+      const destPath = join2(dest, entry.name);
+      if (entry.isDirectory()) {
+        await copySkillDirectory(srcPath, destPath);
+      } else {
+        await cp(srcPath, destPath, { dereference: true, recursive: true });
+      }
+    })
+  );
+}
+function resolveInstallPaths(skillName, agentType, options) {
+  const agent = agents[agentType];
+  if (!agent) return null;
+  const isGlobal = options.global ?? false;
+  const cwd = options.cwd || process.cwd();
+  const sanitized = sanitizeName(skillName);
+  const canonicalBase = getCanonicalSkillsDir(isGlobal, cwd);
+  const canonicalDir = join2(canonicalBase, sanitized);
+  const agentBase = isGlobal ? agent.globalSkillsDir : join2(cwd, agent.skillsDir);
+  const agentDir = join2(agentBase, sanitized);
+  if (!isPathSafe(canonicalBase, canonicalDir) || !isPathSafe(agentBase, agentDir)) {
+    return null;
+  }
+  return { canonicalBase, canonicalDir, agentBase, agentDir };
+}
+async function installSkillFromDir(skillName, skillDir, agentType, options = {}) {
+  const agent = agents[agentType];
+  if (!agent) {
+    return { success: false, path: "", mode: options.mode ?? "symlink", error: `Unknown agent: ${agentType}` };
+  }
+  const isGlobal = options.global ?? false;
+  if (isGlobal && !agent.globalSkillsDir) {
+    return { success: false, path: "", mode: options.mode ?? "symlink", error: `${agent.displayName} does not support global skill installation` };
+  }
+  const paths = resolveInstallPaths(skillName, agentType, options);
+  if (!paths) {
+    return { success: false, path: "", mode: options.mode ?? "symlink", error: "Invalid skill name: potential path traversal detected" };
+  }
+  const { canonicalDir, agentDir } = paths;
+  const installMode = options.mode ?? "symlink";
+  try {
+    if (installMode === "copy") {
+      await cleanAndCreateDirectory(agentDir);
+      await copySkillDirectory(skillDir, agentDir);
+      return { success: true, path: agentDir, mode: "copy" };
+    }
+    await cleanAndCreateDirectory(canonicalDir);
+    await copySkillDirectory(skillDir, canonicalDir);
+    const symlinkCreated = await createSymlink(canonicalDir, agentDir);
+    if (!symlinkCreated) {
+      await cleanAndCreateDirectory(agentDir);
+      await copySkillDirectory(skillDir, agentDir);
+      return { success: true, path: agentDir, canonicalPath: canonicalDir, mode: "symlink", symlinkFailed: true };
+    }
+    return { success: true, path: agentDir, canonicalPath: canonicalDir, mode: "symlink" };
+  } catch (error) {
+    return { success: false, path: agentDir, mode: installMode, error: error instanceof Error ? error.message : "Unknown error" };
+  }
+}
+async function installSkill(skillName, content, agentType, options = {}) {
+  const agent = agents[agentType];
+  if (!agent) {
+    return { success: false, path: "", mode: options.mode ?? "symlink", error: `Unknown agent: ${agentType}` };
+  }
+  const isGlobal = options.global ?? false;
+  if (isGlobal && !agent.globalSkillsDir) {
+    return { success: false, path: "", mode: options.mode ?? "symlink", error: `${agent.displayName} does not support global skill installation` };
+  }
+  const paths = resolveInstallPaths(skillName, agentType, options);
+  if (!paths) {
+    return { success: false, path: "", mode: options.mode ?? "symlink", error: "Invalid skill name: potential path traversal detected" };
+  }
+  const { canonicalDir, agentDir } = paths;
+  const installMode = options.mode ?? "symlink";
+  try {
+    if (installMode === "copy") {
+      await cleanAndCreateDirectory(agentDir);
+      await writeFile(join2(agentDir, "SKILL.md"), content, "utf-8");
+      return { success: true, path: agentDir, mode: "copy" };
+    }
+    await cleanAndCreateDirectory(canonicalDir);
+    await writeFile(join2(canonicalDir, "SKILL.md"), content, "utf-8");
+    const symlinkCreated = await createSymlink(canonicalDir, agentDir);
+    if (!symlinkCreated) {
+      await cleanAndCreateDirectory(agentDir);
+      await writeFile(join2(agentDir, "SKILL.md"), content, "utf-8");
+      return { success: true, path: agentDir, canonicalPath: canonicalDir, mode: "symlink", symlinkFailed: true };
+    }
+    return { success: true, path: agentDir, canonicalPath: canonicalDir, mode: "symlink" };
+  } catch (error) {
+    return { success: false, path: agentDir, mode: installMode, error: error instanceof Error ? error.message : "Unknown error" };
+  }
+}
+async function isSkillInstalled(skillName, agentType, options = {}) {
+  const agent = agents[agentType];
+  if (!agent) return false;
+  const sanitized = sanitizeName(skillName);
+  if (options.global && !agent.globalSkillsDir) {
+    return false;
+  }
+  const targetBase = options.global ? agent.globalSkillsDir : join2(options.cwd || process.cwd(), agent.skillsDir);
+  const skillDir = join2(targetBase, sanitized);
+  if (!isPathSafe(targetBase, skillDir)) {
+    return false;
+  }
+  try {
+    await access(skillDir);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function detectInstalledAgents() {
+  const results = await Promise.all(
+    Object.entries(agents).map(async ([type, config]) => ({
+      type,
+      installed: await config.detectInstalled()
+    }))
+  );
+  return results.filter((r) => r.installed).map((r) => r.type);
+}
+async function listInstalledSkills(options = {}) {
+  const cwd = options.cwd || process.cwd();
+  const installedSkills = [];
+  const scopes = [];
+  if (options.global === void 0) {
+    scopes.push({ global: false, path: getCanonicalSkillsDir(false, cwd) });
+    scopes.push({ global: true, path: getCanonicalSkillsDir(true, cwd) });
+  } else {
+    scopes.push({ global: options.global, path: getCanonicalSkillsDir(options.global, cwd) });
+  }
+  const detectedAgents = await detectInstalledAgents();
+  for (const scope of scopes) {
+    try {
+      const entries = await readdir(scope.path, { withFileTypes: true });
+      for (const entry of entries) {
+        if (!entry.isDirectory()) continue;
+        const skillDir = join2(scope.path, entry.name);
+        try {
+          await access(join2(skillDir, "SKILL.md"));
+        } catch {
+          continue;
+        }
+        const installedAgents = [];
+        for (const agentType of detectedAgents) {
+          const agent = agents[agentType];
+          if (scope.global && !agent.globalSkillsDir) continue;
+          const agentBase = scope.global ? agent.globalSkillsDir : join2(cwd, agent.skillsDir);
+          const agentSkillDir = join2(agentBase, entry.name);
+          try {
+            await access(agentSkillDir);
+            installedAgents.push(agentType);
+          } catch {
+          }
+        }
+        installedSkills.push({
+          name: entry.name,
+          path: skillDir,
+          scope: scope.global ? "global" : "project",
+          agents: installedAgents
+        });
+      }
+    } catch {
+    }
+  }
+  return installedSkills;
+}
+async function removeSkill(skillName, agentType, options = {}) {
+  const agent = agents[agentType];
+  if (!agent) {
+    return { success: false, error: `Unknown agent: ${agentType}` };
+  }
+  const sanitized = sanitizeName(skillName);
+  const cwd = options.cwd || process.cwd();
+  if (options.global && !agent.globalSkillsDir) {
+    return { success: false, error: `${agent.displayName} does not support global skills` };
+  }
+  const agentBase = options.global ? agent.globalSkillsDir : join2(cwd, agent.skillsDir);
+  const skillDir = join2(agentBase, sanitized);
+  if (!isPathSafe(agentBase, skillDir)) {
+    return { success: false, error: "Invalid skill name" };
+  }
+  try {
+    await rm(skillDir, { recursive: true, force: true });
+    return { success: true };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : "Unknown error"
+    };
+  }
+}
+
+// src/updater.ts
+import { existsSync as existsSync2, createWriteStream, unlinkSync, chmodSync, renameSync } from "fs";
+import { join as join3, dirname as dirname2 } from "path";
+import { homedir as homedir3, platform as platform2, arch } from "os";
+import { pipeline } from "stream/promises";
+import { Readable } from "stream";
+import semver from "semver";
+var UPDATE_CHECK_FILE = join3(homedir3(), ".askill", "last-update-check");
+var UPDATE_INTERVAL_MS = 24 * 60 * 60 * 1e3;
+var GITHUB_REPO = "avibe-bot/askill";
+function getPlatformKey() {
+  const p2 = platform2();
+  const a = arch();
+  if (p2 === "darwin") {
+    return a === "arm64" ? "darwin-arm64" : "darwin-x64";
+  } else if (p2 === "linux") {
+    return a === "arm64" ? "linux-arm64" : "linux-x64";
+  } else if (p2 === "win32") {
+    return "win32-x64";
+  }
+  return `${p2}-${a}`;
+}
+async function shouldCheckUpdate() {
+  try {
+    const { readFile: readFile4 } = await import("fs/promises");
+    const lastCheck = await readFile4(UPDATE_CHECK_FILE, "utf-8");
+    const lastCheckTime = parseInt(lastCheck, 10);
+    return Date.now() - lastCheckTime > UPDATE_INTERVAL_MS;
+  } catch {
+    return true;
+  }
+}
+async function saveUpdateCheckTime() {
+  try {
+    const { mkdir: mkdir4, writeFile: writeFile4 } = await import("fs/promises");
+    await mkdir4(dirname2(UPDATE_CHECK_FILE), { recursive: true });
+    await writeFile4(UPDATE_CHECK_FILE, String(Date.now()), "utf-8");
+  } catch {
+  }
+}
+async function fetchVersionInfo() {
+  try {
+    const response = await fetch("https://askill.sh/api/v1/cli/version", {
+      headers: { "User-Agent": `askill/${VERSION}` }
+    });
+    if (response.ok) {
+      return response.json();
+    }
+  } catch {
+  }
+  try {
+    const response = await fetch(
+      `https://api.github.com/repos/${GITHUB_REPO}/releases/latest`,
+      {
+        headers: {
+          "User-Agent": `askill/${VERSION}`,
+          "Accept": "application/vnd.github.v3+json"
+        }
+      }
+    );
+    if (!response.ok) return null;
+    const release = await response.json();
+    const latest = release.tag_name.replace(/^v/, "");
+    const downloadUrls = {};
+    for (const asset of release.assets || []) {
+      const platforms = ["darwin-arm64", "darwin-x64", "linux-arm64", "linux-x64", "win32-x64"];
+      for (const p2 of platforms) {
+        if (asset.name.includes(p2)) {
+          downloadUrls[p2] = asset.browser_download_url;
+        }
+      }
+    }
+    return {
+      latest,
+      minimum: "0.1.0",
+      releaseNotes: release.body?.slice(0, 500) || `Release ${latest}`,
+      releaseUrl: release.html_url,
+      downloadUrls
+    };
+  } catch {
+    return null;
+  }
+}
+async function checkForUpdates(force = false) {
+  if (!force && !await shouldCheckUpdate()) {
+    return;
+  }
+  await saveUpdateCheckTime();
+  const versionInfo = await fetchVersionInfo();
+  if (!versionInfo) return;
+  const current = VERSION;
+  const latest = versionInfo.latest;
+  if (semver.lt(current, latest)) {
+    console.log();
+    console.log(`${YELLOW}\u256D\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u256E${RESET}`);
+    console.log(`${YELLOW}\u2502${RESET}  Update available: ${DIM}${current}${RESET} \u2192 ${GREEN}${latest}${RESET}        ${YELLOW}\u2502${RESET}`);
+    console.log(`${YELLOW}\u2502${RESET}  Run ${CYAN}askill self-update${RESET} to update         ${YELLOW}\u2502${RESET}`);
+    console.log(`${YELLOW}\u2570\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u256F${RESET}`);
+    console.log();
+  }
+  if (semver.lt(current, versionInfo.minimum)) {
+    console.log(`${RED}Your askill version is too old. Please update to continue.${RESET}`);
+    console.log(`Minimum required: ${versionInfo.minimum}`);
+    process.exit(1);
+  }
+}
+async function selfUpdate() {
+  console.log(`${CYAN}Checking for updates...${RESET}`);
+  const versionInfo = await fetchVersionInfo();
+  if (!versionInfo) {
+    console.log(`${RED}Failed to check for updates${RESET}`);
+    return false;
+  }
+  const current = VERSION;
+  const latest = versionInfo.latest;
+  if (semver.gte(current, latest)) {
+    console.log(`${GREEN}You are already on the latest version (${current})${RESET}`);
+    return true;
+  }
+  console.log(`Updating from ${DIM}${current}${RESET} to ${GREEN}${latest}${RESET}...`);
+  const platformKey = getPlatformKey();
+  const downloadUrl = versionInfo.downloadUrls[platformKey];
+  if (!downloadUrl) {
+    console.log(`${RED}No download available for your platform (${platformKey})${RESET}`);
+    console.log(`Please update manually:`);
+    console.log(`  ${CYAN}npm install -g @askill/cli@latest${RESET}`);
+    console.log(`  ${DIM}or${RESET}`);
+    console.log(`  ${CYAN}curl -fsSL https://askill.sh/install.sh | sh${RESET}`);
+    return false;
+  }
+  try {
+    const execPath = process.execPath;
+    const isNodeProcess = execPath.includes("node") || execPath.includes("bun");
+    if (isNodeProcess) {
+      console.log(`${YELLOW}Running via Node.js runtime${RESET}`);
+      console.log(`Please update using: ${CYAN}npm install -g @askill/cli@latest${RESET}`);
+      return false;
+    }
+    const tempPath = `${execPath}.new`;
+    const backupPath = `${execPath}.backup`;
+    console.log(`Downloading ${platformKey} binary...`);
+    const response = await fetch(downloadUrl, {
+      headers: { "User-Agent": `askill/${VERSION}` },
+      redirect: "follow"
+    });
+    if (!response.ok || !response.body) {
+      throw new Error(`Download failed: ${response.status}`);
+    }
+    const writer = createWriteStream(tempPath);
+    await pipeline(Readable.fromWeb(response.body), writer);
+    chmodSync(tempPath, 493);
+    if (existsSync2(execPath)) {
+      renameSync(execPath, backupPath);
+    }
+    renameSync(tempPath, execPath);
+    try {
+      unlinkSync(backupPath);
+    } catch {
+    }
+    console.log(`${GREEN}Successfully updated to v${latest}!${RESET}`);
+    if (versionInfo.releaseNotes) {
+      console.log(`${DIM}Release notes: ${versionInfo.releaseNotes.slice(0, 200)}${RESET}`);
+    }
+    return true;
+  } catch (error) {
+    console.log(`${RED}Update failed: ${error instanceof Error ? error.message : "Unknown error"}${RESET}`);
+    console.log(`Please update manually:`);
+    console.log(`  ${CYAN}npm install -g @askill/cli@latest${RESET}`);
+    console.log(`  ${DIM}or${RESET}`);
+    console.log(`  ${CYAN}curl -fsSL https://askill.sh/install.sh | sh${RESET}`);
+    return false;
+  }
+}
+
+// src/config.ts
+import { mkdir as mkdir2, readFile, writeFile as writeFile2 } from "fs/promises";
+import { join as join4 } from "path";
+import { homedir as homedir4 } from "os";
+var CONFIG_DIR = process.env.XDG_CONFIG_HOME || join4(homedir4(), ".config");
+var ASKILL_CONFIG_DIR = join4(CONFIG_DIR, "askill");
+var CONFIG_FILE = join4(ASKILL_CONFIG_DIR, "config.json");
+async function loadConfig() {
+  try {
+    const content = await readFile(CONFIG_FILE, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return {};
+  }
+}
+async function getPreferredAgents() {
+  const config = await loadConfig();
+  return config.preferredAgents;
+}
+
+// src/parser.ts
+function parseSkillMd(content) {
+  const frontmatterRegex = /^---\r?\n([\s\S]*?)\r?\n---/;
+  const match = content.match(frontmatterRegex);
+  if (!match) {
+    return {
+      frontmatter: {},
+      content: content.trim()
+    };
+  }
+  const yamlContent = match[1];
+  const markdownContent = content.slice(match[0].length).trim();
+  const frontmatter = parseYaml(yamlContent);
+  return {
+    frontmatter,
+    content: markdownContent
+  };
+}
+function parseYaml(yaml) {
+  const result = {};
+  const lines = yaml.split("\n");
+  let currentKey = null;
+  let currentArray = null;
+  let currentObject = null;
+  let inCommandsBlock = false;
+  let currentCommand = null;
+  let commandsResult = {};
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const indent = line.search(/\S/);
+    if (indent === 0 && trimmed.includes(":")) {
+      if (currentKey && currentArray) {
+        result[currentKey] = currentArray;
+        currentArray = null;
+      }
+      if (currentKey && currentObject) {
+        result[currentKey] = currentObject;
+        currentObject = null;
+      }
+      if (inCommandsBlock) {
+        result.commands = commandsResult;
+        inCommandsBlock = false;
+      }
+      const colonIndex = trimmed.indexOf(":");
+      const key = trimmed.slice(0, colonIndex).trim();
+      const value = trimmed.slice(colonIndex + 1).trim();
+      currentKey = key;
+      if (key === "commands") {
+        inCommandsBlock = true;
+        commandsResult = {};
+        continue;
+      }
+      if (value) {
+        result[key] = parseValue(value);
+        currentKey = null;
+      }
+      continue;
+    }
+    if (inCommandsBlock) {
+      if (indent === 2 && trimmed.includes(":") && !trimmed.startsWith("-")) {
+        const colonIndex = trimmed.indexOf(":");
+        const cmdName = trimmed.slice(0, colonIndex).trim();
+        const cmdValue = trimmed.slice(colonIndex + 1).trim();
+        if (!cmdValue) {
+          currentCommand = cmdName;
+          commandsResult[cmdName] = { run: "", description: "" };
+        }
+        continue;
+      }
+      if (indent === 4 && currentCommand && trimmed.includes(":")) {
+        const colonIndex = trimmed.indexOf(":");
+        const propKey = trimmed.slice(0, colonIndex).trim();
+        const propValue = trimmed.slice(colonIndex + 1).trim();
+        if (propKey === "run" || propKey === "description") {
+          commandsResult[currentCommand][propKey] = parseValue(propValue);
+        }
+        continue;
+      }
+      continue;
+    }
+    if (trimmed.startsWith("-")) {
+      if (!currentArray) currentArray = [];
+      const itemValue = trimmed.slice(1).trim();
+      currentArray.push(parseValue(itemValue));
+      continue;
+    }
+    if (indent > 0 && currentKey && trimmed.includes(":")) {
+      if (!currentObject) currentObject = {};
+      const colonIndex = trimmed.indexOf(":");
+      const propKey = trimmed.slice(0, colonIndex).trim();
+      const propValue = trimmed.slice(colonIndex + 1).trim();
+      currentObject[propKey] = parseValue(propValue);
+      continue;
+    }
+  }
+  if (currentKey && currentArray) {
+    result[currentKey] = currentArray;
+  }
+  if (currentKey && currentObject) {
+    result[currentKey] = currentObject;
+  }
+  if (inCommandsBlock) {
+    result.commands = commandsResult;
+  }
+  return result;
+}
+function parseValue(value) {
+  if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+    return value.slice(1, -1);
+  }
+  return value;
+}
+function extractDependencies(content) {
+  const { frontmatter } = parseSkillMd(content);
+  return frontmatter.dependencies || [];
+}
+function parseDependency(dep) {
+  if (dep.startsWith("gh:")) {
+    const rest = dep.slice(3);
+    if (rest.includes("@")) {
+      const [repoPath, skillName] = rest.split("@");
+      const [owner, repo] = repoPath.split("/");
+      return {
+        type: "github",
+        raw: dep,
+        owner,
+        repo,
+        skill: skillName
+      };
+    }
+    const parts = rest.split("/");
+    if (parts.length >= 3) {
+      return {
+        type: "github",
+        raw: dep,
+        owner: parts[0],
+        repo: parts[1],
+        path: parts.slice(2).join("/")
+      };
+    }
+    return {
+      type: "github",
+      raw: dep,
+      owner: parts[0],
+      repo: parts[1]
+    };
+  }
+  if (dep.startsWith("@")) {
+    const withoutPrefix = dep.slice(1);
+    const slashIndex = withoutPrefix.indexOf("/");
+    if (slashIndex === -1) {
+      return { type: "published", raw: dep };
+    }
+    const scope = withoutPrefix.slice(0, slashIndex);
+    const rest = withoutPrefix.slice(slashIndex + 1);
+    const atIndex = rest.indexOf("@");
+    if (atIndex !== -1) {
+      const name = rest.slice(0, atIndex);
+      const version = rest.slice(atIndex + 1);
+      return { type: "published", raw: dep, scope, name, version };
+    }
+    return { type: "published", raw: dep, scope, name: rest };
+  }
+  return { type: "published", raw: dep };
+}
+function dependencyToSlug(dep) {
+  if (dep.type === "github") {
+    if (dep.skill) {
+      return `gh:${dep.owner}/${dep.repo}@${dep.skill}`;
+    }
+    if (dep.path) {
+      return `gh:${dep.owner}/${dep.repo}/${dep.path}`;
+    }
+    return `gh:${dep.owner}/${dep.repo}`;
+  }
+  if (dep.scope && dep.name) {
+    return `@${dep.scope}/${dep.name}`;
+  }
+  return dep.raw;
+}
+
+// src/source-parser.ts
+import { isAbsolute, resolve as resolve2 } from "path";
+function parseSource(input) {
+  if (isLocalPath(input)) {
+    const resolvedPath = resolve2(input);
+    return {
+      type: "local",
+      url: resolvedPath,
+      localPath: resolvedPath
+    };
+  }
+  const normalized = input.startsWith("gh:") ? input.slice(3) : input;
+  const hadGhPrefix = input.startsWith("gh:");
+  const githubTreeWithPathMatch = normalized.match(/github\.com\/([^/]+)\/([^/]+)\/tree\/([^/]+)\/(.+)/);
+  if (githubTreeWithPathMatch) {
+    const [, owner, repo, ref, subpath] = githubTreeWithPathMatch;
+    return {
+      type: "github",
+      url: `https://github.com/${owner}/${repo}.git`,
+      owner,
+      repo,
+      ref,
+      subpath
+    };
+  }
+  const githubTreeMatch = normalized.match(/github\.com\/([^/]+)\/([^/]+)\/tree\/([^/]+)$/);
+  if (githubTreeMatch) {
+    const [, owner, repo, ref] = githubTreeMatch;
+    return {
+      type: "github",
+      url: `https://github.com/${owner}/${repo}.git`,
+      owner,
+      repo,
+      ref
+    };
+  }
+  const githubUrlMatch = normalized.match(/github\.com\/([^/]+)\/([^/]+)/);
+  if (githubUrlMatch) {
+    const [, owner, repo] = githubUrlMatch;
+    const cleanRepo = repo.replace(/\.git$/, "");
+    return {
+      type: "github",
+      url: `https://github.com/${owner}/${cleanRepo}.git`,
+      owner,
+      repo: cleanRepo
+    };
+  }
+  const atSkillMatch = normalized.match(/^([^/]+)\/([^/@]+)@(.+)$/);
+  if (atSkillMatch && !normalized.includes(":")) {
+    const [, owner, repo, skillFilter] = atSkillMatch;
+    return {
+      type: "github",
+      url: `https://github.com/${owner}/${repo}.git`,
+      owner,
+      repo,
+      skillFilter
+    };
+  }
+  const shorthandMatch = normalized.match(/^([^/]+)\/([^/]+)(?:\/(.+))?$/);
+  if (shorthandMatch && !normalized.includes(":") && !normalized.startsWith(".") && !normalized.startsWith("/")) {
+    const [, owner, repo, subpath] = shorthandMatch;
+    return {
+      type: "github",
+      url: `https://github.com/${owner}/${repo}.git`,
+      owner,
+      repo,
+      subpath
+    };
+  }
+  return {
+    type: "git",
+    url: normalized
+  };
+}
+function isLocalPath(input) {
+  return isAbsolute(input) || input.startsWith("./") || input.startsWith("../") || input === "." || input === ".." || /^[a-zA-Z]:[/\\]/.test(input);
+}
+
+// src/discover.ts
+import { readdir as readdir2, readFile as readFile2, stat } from "fs/promises";
+import { join as join5 } from "path";
+var SKIP_DIRS = /* @__PURE__ */ new Set(["node_modules", ".git", "dist", "build", "__pycache__"]);
+async function hasSkillMd(dir) {
+  try {
+    const skillPath = join5(dir, "SKILL.md");
+    const stats = await stat(skillPath);
+    return stats.isFile();
+  } catch {
+    return false;
+  }
+}
+async function parseSkillDir(dir) {
+  try {
+    const skillPath = join5(dir, "SKILL.md");
+    const content = await readFile2(skillPath, "utf-8");
+    const parsed = parseSkillMd(content);
+    if (!parsed.frontmatter.name || !parsed.frontmatter.description) {
+      return null;
+    }
+    return {
+      name: parsed.frontmatter.name,
+      description: parsed.frontmatter.description,
+      path: dir,
+      rawContent: content,
+      frontmatter: parsed.frontmatter
+    };
+  } catch {
+    return null;
+  }
+}
+async function findSkillDirs(dir, depth = 0, maxDepth = 5) {
+  if (depth > maxDepth) return [];
+  try {
+    const [hasSkill, entries] = await Promise.all([
+      hasSkillMd(dir),
+      readdir2(dir, { withFileTypes: true }).catch(() => [])
+    ]);
+    const currentDir = hasSkill ? [dir] : [];
+    const subDirResults = await Promise.all(
+      entries.filter((entry) => entry.isDirectory() && !SKIP_DIRS.has(entry.name)).map((entry) => findSkillDirs(join5(dir, entry.name), depth + 1, maxDepth))
+    );
+    return [...currentDir, ...subDirResults.flat()];
+  } catch {
+    return [];
+  }
+}
+async function discoverSkills(basePath, subpath) {
+  const skills = [];
+  const seenNames = /* @__PURE__ */ new Set();
+  const searchPath = subpath ? join5(basePath, subpath) : basePath;
+  if (await hasSkillMd(searchPath)) {
+    const skill = await parseSkillDir(searchPath);
+    if (skill) {
+      return [skill];
+    }
+  }
+  const prioritySearchDirs = [
+    searchPath,
+    join5(searchPath, "skills"),
+    join5(searchPath, "skills/.curated"),
+    join5(searchPath, "skills/.experimental"),
+    join5(searchPath, ".agents/skills"),
+    join5(searchPath, ".claude/skills"),
+    join5(searchPath, ".opencode/skills"),
+    join5(searchPath, ".cursor/skills"),
+    join5(searchPath, ".codex/skills"),
+    join5(searchPath, ".cline/skills"),
+    join5(searchPath, ".gemini/skills"),
+    join5(searchPath, ".windsurf/skills"),
+    join5(searchPath, ".roo/skills"),
+    join5(searchPath, ".github/skills"),
+    join5(searchPath, ".goose/skills")
+  ];
+  for (const dir of prioritySearchDirs) {
+    try {
+      const entries = await readdir2(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.isDirectory()) {
+          const skillDir = join5(dir, entry.name);
+          if (await hasSkillMd(skillDir)) {
+            const skill = await parseSkillDir(skillDir);
+            if (skill && !seenNames.has(skill.name)) {
+              skills.push(skill);
+              seenNames.add(skill.name);
+            }
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  if (skills.length === 0) {
+    const allSkillDirs = await findSkillDirs(searchPath);
+    for (const skillDir of allSkillDirs) {
+      const skill = await parseSkillDir(skillDir);
+      if (skill && !seenNames.has(skill.name)) {
+        skills.push(skill);
+        seenNames.add(skill.name);
+      }
+    }
+  }
+  return skills;
+}
+function filterSkills(skills, names) {
+  const normalizedNames = names.map((n) => n.toLowerCase());
+  return skills.filter((skill) => {
+    const name = skill.name.toLowerCase();
+    return normalizedNames.some((input) => input === name);
+  });
+}
+
+// src/git.ts
+import { execFile } from "child_process";
+import { mkdtemp, rm as rm2 } from "fs/promises";
+import { join as join6, normalize as normalize2, resolve as resolve3, sep as sep2 } from "path";
+import { tmpdir } from "os";
+var CLONE_TIMEOUT_MS = 6e4;
+var GitCloneError = class extends Error {
+  url;
+  isTimeout;
+  isAuthError;
+  constructor(message, url, isTimeout = false, isAuthError = false) {
+    super(message);
+    this.name = "GitCloneError";
+    this.url = url;
+    this.isTimeout = isTimeout;
+    this.isAuthError = isAuthError;
+  }
+};
+async function cloneRepo(url, ref) {
+  const tempDir = await mkdtemp(join6(tmpdir(), "askill-"));
+  const args = ["clone", "--depth", "1"];
+  if (ref) {
+    args.push("--branch", ref);
+  }
+  args.push(url, tempDir);
+  try {
+    await execGit(args);
+    return tempDir;
+  } catch (error) {
+    await rm2(tempDir, { recursive: true, force: true }).catch(() => {
+    });
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    const isTimeout = errorMessage.includes("timed out") || errorMessage.includes("timeout");
+    const isAuthError = errorMessage.includes("Authentication failed") || errorMessage.includes("could not read Username") || errorMessage.includes("Permission denied") || errorMessage.includes("Repository not found");
+    if (isTimeout) {
+      throw new GitCloneError(
+        `Clone timed out after 60s. This may happen with private repos.
+  Ensure SSH keys or credentials are configured.`,
+        url,
+        true,
+        false
+      );
+    }
+    if (isAuthError) {
+      throw new GitCloneError(
+        `Authentication failed for ${url}.
+  For SSH: Check keys with 'ssh -T git@github.com'
+  For HTTPS: Run 'gh auth login'`,
+        url,
+        false,
+        true
+      );
+    }
+    throw new GitCloneError(`Failed to clone ${url}: ${errorMessage}`, url);
+  }
+}
+async function cleanupTempDir(dir) {
+  const normalizedDir = normalize2(resolve3(dir));
+  const normalizedTmpDir = normalize2(resolve3(tmpdir()));
+  if (!normalizedDir.startsWith(normalizedTmpDir + sep2) && normalizedDir !== normalizedTmpDir) {
+    throw new Error("Attempted to clean up directory outside of temp directory");
+  }
+  await rm2(dir, { recursive: true, force: true });
+}
+function execGit(args) {
+  return new Promise((resolve4, reject) => {
+    const child = execFile("git", args, { timeout: CLONE_TIMEOUT_MS }, (error, stdout, stderr) => {
+      if (error) {
+        reject(new Error(stderr || error.message));
+      } else {
+        resolve4(stdout);
+      }
+    });
+  });
+}
+
+// src/lock.ts
+import { readFile as readFile3, writeFile as writeFile3, mkdir as mkdir3 } from "fs/promises";
+import { join as join7, dirname as dirname5 } from "path";
+import { homedir as homedir5 } from "os";
+var AGENTS_DIR2 = ".agents";
+var LOCK_FILE = ".skill-lock.json";
+var CURRENT_VERSION = 3;
+function getSkillLockPath() {
+  return join7(homedir5(), AGENTS_DIR2, LOCK_FILE);
+}
+function createEmptyLockFile() {
+  return {
+    version: CURRENT_VERSION,
+    skills: {}
+  };
+}
+async function readSkillLock() {
+  const lockPath = getSkillLockPath();
+  try {
+    const content = await readFile3(lockPath, "utf-8");
+    const parsed = JSON.parse(content);
+    if (typeof parsed.version !== "number" || !parsed.skills) {
+      return createEmptyLockFile();
+    }
+    if (parsed.version < CURRENT_VERSION) {
+      return createEmptyLockFile();
+    }
+    return parsed;
+  } catch {
+    return createEmptyLockFile();
+  }
+}
+async function writeSkillLock(lock) {
+  const lockPath = getSkillLockPath();
+  await mkdir3(dirname5(lockPath), { recursive: true });
+  const content = JSON.stringify(lock, null, 2);
+  await writeFile3(lockPath, content, "utf-8");
+}
+async function addSkillToLock(skillName, entry) {
+  const lock = await readSkillLock();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const existingEntry = lock.skills[skillName];
+  lock.skills[skillName] = {
+    ...entry,
+    installedAt: existingEntry?.installedAt ?? now,
+    updatedAt: now
+  };
+  await writeSkillLock(lock);
+}
+async function removeSkillFromLock(skillName) {
+  const lock = await readSkillLock();
+  if (!(skillName in lock.skills)) {
+    return false;
+  }
+  delete lock.skills[skillName];
+  await writeSkillLock(lock);
+  return true;
+}
+async function getAllLockedSkills() {
+  const lock = await readSkillLock();
+  return lock.skills;
+}
+async function getLastSelectedAgents() {
+  const lock = await readSkillLock();
+  return lock.lastSelectedAgents;
+}
+async function saveLastSelectedAgents(agents2) {
+  const lock = await readSkillLock();
+  lock.lastSelectedAgents = agents2;
+  await writeSkillLock(lock);
+}
+async function fetchSkillFolderHash(ownerRepo, skillPath) {
+  let folderPath = skillPath.replace(/\\/g, "/");
+  if (folderPath.endsWith("/SKILL.md")) {
+    folderPath = folderPath.slice(0, -9);
+  } else if (folderPath.endsWith("SKILL.md")) {
+    folderPath = folderPath.slice(0, -8);
+  }
+  if (folderPath.endsWith("/")) {
+    folderPath = folderPath.slice(0, -1);
+  }
+  const branches = ["main", "master"];
+  for (const branch of branches) {
+    try {
+      const url = `https://api.github.com/repos/${ownerRepo}/git/trees/${branch}?recursive=1`;
+      const response = await fetch(url, {
+        headers: {
+          Accept: "application/vnd.github.v3+json",
+          "User-Agent": "askill-cli"
+        }
+      });
+      if (!response.ok) continue;
+      const data = await response.json();
+      if (!folderPath) {
+        return data.sha;
+      }
+      const folderEntry = data.tree.find(
+        (entry) => entry.type === "tree" && entry.path === folderPath
+      );
+      if (folderEntry) {
+        return folderEntry.sha;
+      }
+    } catch {
+      continue;
+    }
+  }
+  return "";
+}
+
+// src/cli.ts
+import { join as join8 } from "path";
+import { homedir as homedir6 } from "os";
+import * as p from "@clack/prompts";
+import pc from "picocolors";
+var LOGO = `
+ \u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2557  \u2588\u2588\u2557\u2588\u2588\u2557\u2588\u2588\u2557     \u2588\u2588\u2557     
+\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D\u2588\u2588\u2551 \u2588\u2588\u2554\u255D\u2588\u2588\u2551\u2588\u2588\u2551     \u2588\u2588\u2551     
+\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2554\u255D \u2588\u2588\u2551\u2588\u2588\u2551     \u2588\u2588\u2551     
+\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2551\u255A\u2550\u2550\u2550\u2550\u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2588\u2588\u2557 \u2588\u2588\u2551\u2588\u2588\u2551     \u2588\u2588\u2551     
+\u2588\u2588\u2551  \u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2551\u2588\u2588\u2551  \u2588\u2588\u2557\u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557
+\u255A\u2550\u255D  \u255A\u2550\u255D\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D\u255A\u2550\u255D  \u255A\u2550\u255D\u255A\u2550\u255D\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D
+`.trim();
+function showLogo() {
+  const lines = LOGO.split("\n");
+  const grays = ["\x1B[38;5;250m", "\x1B[38;5;248m", "\x1B[38;5;245m", "\x1B[38;5;243m", "\x1B[38;5;240m", "\x1B[38;5;238m"];
+  console.log();
+  lines.forEach((line, i) => {
+    console.log(`${grays[i] || grays[grays.length - 1]}${line}${RESET}`);
+  });
+}
+function showBanner() {
+  showLogo();
+  console.log();
+  console.log(`${DIM}The Agent Skill Package Manager${RESET}`);
+  console.log();
+  console.log(`  ${DIM}$${RESET} askill add ${DIM}<skill>${RESET}       ${DIM}Install a skill${RESET}`);
+  console.log(`  ${DIM}$${RESET} askill find ${DIM}[query]${RESET}      ${DIM}Search for skills${RESET}`);
+  console.log(`  ${DIM}$${RESET} askill list${RESET}              ${DIM}List installed skills${RESET}`);
+  console.log(`  ${DIM}$${RESET} askill remove ${DIM}<skill>${RESET}   ${DIM}Remove a skill${RESET}`);
+  console.log(`  ${DIM}$${RESET} askill init${RESET}              ${DIM}Create a new skill${RESET}`);
+  console.log(`  ${DIM}$${RESET} askill run ${DIM}<skill:cmd>${RESET}  ${DIM}Run a skill command${RESET}`);
+  console.log();
+  console.log(`${DIM}Browse skills at${RESET} ${CYAN}https://askill.sh${RESET}`);
+  console.log();
+}
+function showHelp() {
+  console.log(`
+${BOLD}Usage:${RESET} askill <command> [options]
+
+${BOLD}Commands:${RESET}
+  add, install, i <skill>  Install a skill from askill.sh
+  remove, rm <skill>       Remove an installed skill
+  list, ls                 List installed skills
+  find, search, s [query]  Search for skills
+  info <skill>             Show skill details
+  init [dir]               Create a new SKILL.md template
+  validate [path]          Validate a SKILL.md file
+  check                    Check installed skills for updates
+  update [skill]           Update installed skills
+  run <skill:cmd>          Run a skill command
+  self-update              Update askill CLI
+
+${BOLD}Skill Source Formats:${RESET}
+  owner/repo                          All skills from a GitHub repo
+  owner/repo@skill-name               Specific skill by name
+  owner/repo/path/to/skill            Specific skill by path
+  https://github.com/owner/repo       Full GitHub URL
+  ./local/path                        Local directory
+  gh:owner/repo@skill-name            Explicit GitHub prefix (optional)
+
+${BOLD}Install Options:${RESET}
+  -g, --global          Install globally (user-level)
+  -a, --agent <agents>  Install to specific agents
+  -y, --yes             Skip confirmation prompts
+  --copy                Copy files instead of symlink
+  -l, --list            Preview skills in a repo without installing
+  --all                 Install all discovered skills (skip selection)
+
+${BOLD}Run Options:${RESET}
+  askill run <skill>:<command>      Run a skill's command
+
+${BOLD}Options:${RESET}
+  --help, -h            Show this help message
+  --version, -v         Show version number
+
+${BOLD}Examples:${RESET}
+  ${DIM}$${RESET} askill add anthropic/courses@prompt-eng
+  ${DIM}$${RESET} askill add anthropic/courses
+  ${DIM}$${RESET} askill add ./my-skills/custom-skill
+  ${DIM}$${RESET} askill find memory
+  ${DIM}$${RESET} askill list -g
+  ${DIM}$${RESET} askill info gh:anthropic/courses@prompt-eng
+
+${DIM}Browse more at${RESET} ${CYAN}https://askill.sh${RESET}
+`);
+}
+function parseInstallOptions(args) {
+  const options = {};
+  let skillName = "";
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "-g" || arg === "--global") {
+      options.global = true;
+    } else if (arg === "-y" || arg === "--yes") {
+      options.yes = true;
+    } else if (arg === "--copy") {
+      options.copy = true;
+    } else if (arg === "-l" || arg === "--list") {
+      options.list = true;
+    } else if (arg === "--all") {
+      options.all = true;
+    } else if (arg === "-a" || arg === "--agent") {
+      options.agent = [];
+      while (i + 1 < args.length && !args[i + 1].startsWith("-")) {
+        i++;
+        options.agent.push(args[i]);
+      }
+    } else if (!arg.startsWith("-")) {
+      skillName = arg;
+    }
+  }
+  return { skillName, options };
+}
+async function resolveSkills(source, spinner2, options) {
+  const parsed = parseSource(source);
+  if (parsed.type === "local") {
+    spinner2.start(`Scanning ${source}...`);
+    const skills = await discoverSkills(parsed.localPath);
+    spinner2.stop(`Found ${skills.length} skill(s) in ${pc.cyan(source)}`);
+    return { skills, parsed };
+  }
+  if (parsed.type === "github" || parsed.type === "git") {
+    spinner2.start(`Cloning ${parsed.owner ? `${parsed.owner}/${parsed.repo}` : parsed.url}...`);
+    try {
+      const tempDir = await cloneRepo(parsed.url, parsed.ref);
+      spinner2.stop("Repository cloned");
+      spinner2.start("Discovering skills...");
+      let skills = await discoverSkills(tempDir, parsed.subpath);
+      if (parsed.skillFilter) {
+        skills = filterSkills(skills, [parsed.skillFilter]);
+      }
+      spinner2.stop(`Found ${skills.length} skill(s)`);
+      return { skills, parsed, tempDir };
+    } catch (error) {
+      if (parsed.type === "github" && parsed.owner && parsed.repo) {
+        const errorMsg = error instanceof GitCloneError ? error.message : "Clone failed";
+        spinner2.stop(pc.yellow(`Git clone failed, trying askill.sh...`));
+        try {
+          return await resolveSkillsViaApi(parsed, spinner2, options);
+        } catch (apiError) {
+          spinner2.stop(pc.red("Failed"));
+          p.log.error(`Git clone: ${errorMsg}`);
+          p.log.error(`API fallback: ${apiError instanceof Error ? apiError.message : "Failed"}`);
+          p.outro(pc.red("Could not resolve skill"));
+          process.exit(1);
+        }
+      }
+      spinner2.stop(pc.red("Clone failed"));
+      if (error instanceof GitCloneError) {
+        p.log.error(error.message);
+      }
+      p.outro(pc.red("Could not clone repository"));
+      process.exit(1);
+    }
+  }
+  return { skills: [], parsed };
+}
+async function resolveSkillsViaApi(parsed, spinner2, options) {
+  const { owner, repo, skillFilter, subpath } = parsed;
+  if (skillFilter) {
+    const slug = `${owner}/${repo}@${skillFilter}`;
+    spinner2.start(`Fetching ${slug} from askill.sh...`);
+    const skill = await api.getSkill(slug);
+    const content = await api.getSkillRaw(slug);
+    spinner2.stop(`Found: ${pc.cyan(skill.name)}`);
+    return {
+      skills: [{
+        name: skill.name || "unknown",
+        description: skill.description || "",
+        path: "",
+        // No local path (API-only)
+        rawContent: content,
+        frontmatter: { name: skill.name || void 0, description: skill.description || void 0 }
+      }],
+      parsed
+    };
+  }
+  if (subpath) {
+    const slug = `${owner}/${repo}/${subpath}`;
+    spinner2.start(`Fetching ${slug} from askill.sh...`);
+    const skill = await api.getSkill(slug);
+    const skillSlug = skill.owner && skill.repo && skill.name ? `${skill.owner}/${skill.repo}@${skill.name}` : String(skill.id);
+    const content = await api.getSkillRaw(skillSlug);
+    spinner2.stop(`Found: ${pc.cyan(skill.name)}`);
+    return {
+      skills: [{
+        name: skill.name || "unknown",
+        description: skill.description || "",
+        path: "",
+        rawContent: content,
+        frontmatter: { name: skill.name || void 0, description: skill.description || void 0 }
+      }],
+      parsed
+    };
+  }
+  spinner2.start(`Fetching skills from ${owner}/${repo} on askill.sh...`);
+  const repoData = await api.getRepoSkills(owner, repo);
+  spinner2.stop(`Found ${repoData.skills.length} skill(s)`);
+  const results = [];
+  for (const s of repoData.skills) {
+    const slug = `${owner}/${repo}@${s.name}`;
+    try {
+      const content = await api.getSkillRaw(slug);
+      results.push({
+        name: s.name || "unknown",
+        description: s.description || "",
+        path: "",
+        rawContent: content,
+        frontmatter: { name: s.name || void 0, description: s.description || void 0 }
+      });
+    } catch {
+    }
+  }
+  return { skills: results, parsed };
+}
+async function runInstall(args) {
+  const { skillName, options } = parseInstallOptions(args);
+  if (!skillName) {
+    console.log(`${RED}Error: Missing skill identifier${RESET}`);
+    console.log(`Usage: askill add <source>`);
+    console.log(`
+Formats supported:`);
+    console.log(`  askill add owner/repo                         ${DIM}# all skills from repo${RESET}`);
+    console.log(`  askill add owner/repo@skill-name              ${DIM}# specific skill${RESET}`);
+    console.log(`  askill add owner/repo/path/to/skill           ${DIM}# skill by path${RESET}`);
+    console.log(`  askill add https://github.com/owner/repo      ${DIM}# full GitHub URL${RESET}`);
+    console.log(`  askill add ./local/path                       ${DIM}# local directory${RESET}`);
+    process.exit(1);
+  }
+  console.log();
+  p.intro(pc.bgCyan(pc.black(" askill install ")));
+  const spinner2 = p.spinner();
+  const { skills: discoveredSkills, parsed: sourceParsed, tempDir } = await resolveSkills(skillName, spinner2, options);
+  const cleanup = async () => {
+    if (tempDir) await cleanupTempDir(tempDir).catch(() => {
+    });
+  };
+  try {
+    if (discoveredSkills.length === 0) {
+      p.log.warning("No skills found");
+      p.outro(`Browse skills at ${pc.cyan("https://askill.sh")}`);
+      return;
+    }
+    if (options.list) {
+      console.log();
+      p.log.info(`Found ${discoveredSkills.length} skill(s) in ${pc.cyan(skillName)}:`);
+      console.log();
+      for (const skill of discoveredSkills) {
+        console.log(`  ${pc.cyan(skill.name)}`);
+        if (skill.description) {
+          console.log(`  ${pc.dim(skill.description.slice(0, 80))}${skill.description.length > 80 ? "..." : ""}`);
+        }
+        if (skill.path) {
+          console.log(`  ${pc.dim("path:")} ${skill.path.replace(tempDir || "", "").replace(/^\//, "")}`);
+        }
+        console.log();
+      }
+      p.outro(`Install with: ${pc.cyan(`askill add ${skillName} --all`)}`);
+      return;
+    }
+    let skillsToInstall;
+    if (discoveredSkills.length === 1 || options.yes || options.all) {
+      skillsToInstall = discoveredSkills;
+      if (discoveredSkills.length === 1) {
+        p.log.info(`Installing: ${pc.cyan(discoveredSkills[0].name)}`);
+      } else {
+        p.log.info(`Installing ${discoveredSkills.length} skill(s)`);
+      }
+    } else {
+      const selected = await p.multiselect({
+        message: "Select skills to install",
+        options: discoveredSkills.map((s) => ({
+          value: s,
+          label: s.name,
+          hint: s.description.slice(0, 60) + (s.description.length > 60 ? "..." : "")
+        }))
+      });
+      if (p.isCancel(selected)) {
+        p.cancel("Installation cancelled");
+        return;
+      }
+      skillsToInstall = selected;
+    }
+    let targetAgents;
+    const validAgents = Object.keys(agents);
+    if (options.agent && options.agent.length > 0) {
+      const invalidAgents = options.agent.filter((a) => !validAgents.includes(a));
+      if (invalidAgents.length > 0) {
+        p.log.error(`Invalid agents: ${invalidAgents.join(", ")}`);
+        p.log.info(`Valid agents: ${validAgents.slice(0, 10).join(", ")}...`);
+        return;
+      }
+      targetAgents = options.agent;
+    } else {
+      spinner2.start("Detecting installed agents...");
+      const installedAgents = await detectInstalledAgents();
+      const preferredAgents = await getLastSelectedAgents() || await getPreferredAgents();
+      spinner2.stop(`Found ${installedAgents.length} agent(s)`);
+      if (installedAgents.length === 0) {
+        if (options.yes) {
+          targetAgents = validAgents.slice(0, 5);
+          p.log.info("Installing to default agents");
+        } else {
+          const selected = await p.multiselect({
+            message: "Select agents to install to",
+            options: validAgents.slice(0, 15).map((a) => ({
+              value: a,
+              label: agents[a].displayName
+            }))
+          });
+          if (p.isCancel(selected)) {
+            p.cancel("Installation cancelled");
+            return;
+          }
+          targetAgents = selected;
+        }
+      } else if (installedAgents.length === 1) {
+        targetAgents = installedAgents;
+        p.log.info(`Installing to: ${targetAgents.map((a) => pc.cyan(agents[a].displayName)).join(", ")}`);
+      } else if (options.yes) {
+        const effectiveAgents = preferredAgents ? preferredAgents.filter((a) => installedAgents.includes(a)) : [];
+        targetAgents = effectiveAgents.length > 0 ? effectiveAgents : installedAgents;
+        p.log.info(`Installing to: ${targetAgents.map((a) => pc.cyan(agents[a].displayName)).join(", ")}`);
+      } else {
+        const initialSelection = preferredAgents ? preferredAgents.filter((a) => installedAgents.includes(a)) : installedAgents;
+        const selected = await p.multiselect({
+          message: "Select agents to install to",
+          options: installedAgents.map((a) => ({
+            value: a,
+            label: agents[a].displayName
+          })),
+          initialValues: initialSelection.length > 0 ? initialSelection : installedAgents
+        });
+        if (p.isCancel(selected)) {
+          p.cancel("Installation cancelled");
+          return;
+        }
+        targetAgents = selected;
+      }
+    }
+    let installGlobally = options.global ?? false;
+    if (options.global === void 0 && !options.yes) {
+      const scope = await p.select({
+        message: "Installation scope",
+        options: [
+          { value: false, label: "Project", hint: "Install in current directory" },
+          { value: true, label: "Global", hint: "Install in home directory (all projects)" }
+        ]
+      });
+      if (p.isCancel(scope)) {
+        p.cancel("Installation cancelled");
+        return;
+      }
+      installGlobally = scope;
+    }
+    const installMode = options.copy ? "copy" : "symlink";
+    if (!options.yes) {
+      const skillNames = skillsToInstall.map((s) => s.name).join(", ");
+      const confirmed = await p.confirm({
+        message: `Install ${pc.cyan(skillNames)} to ${targetAgents.length} agent(s)?`
+      });
+      if (p.isCancel(confirmed) || !confirmed) {
+        p.cancel("Installation cancelled");
+        return;
+      }
+    }
+    spinner2.start("Installing...");
+    const allResults = [];
+    const installedNames = /* @__PURE__ */ new Set();
+    const normalizeDepKey = (s) => s.replace(/^gh:/, "").toLowerCase();
+    const toApiSlug = (s) => s.replace(/^gh:/, "");
+    async function installOneSkill(skill, isDependency) {
+      spinner2.message(`Installing ${skill.name}...`);
+      for (const agent of targetAgents) {
+        let result;
+        if (skill.path) {
+          result = await installSkillFromDir(skill.name, skill.path, agent, {
+            global: installGlobally,
+            mode: installMode
+          });
+        } else {
+          result = await installSkill(skill.name, skill.rawContent, agent, {
+            global: installGlobally,
+            mode: installMode
+          });
+        }
+        allResults.push({ skill: skill.name, agent, ...result, isDependency });
+      }
+    }
+    async function installDependencies(skill) {
+      const dependencies = extractDependencies(skill.rawContent);
+      if (dependencies.length === 0) return;
+      spinner2.message(`Resolving dependencies for ${skill.name}...`);
+      for (const dep of dependencies) {
+        const parsed = parseDependency(dep);
+        const depSlug = dependencyToSlug(parsed);
+        const depKey = normalizeDepKey(depSlug);
+        if (installedNames.has(depKey)) continue;
+        installedNames.add(depKey);
+        try {
+          const apiSlug = toApiSlug(depSlug);
+          const depSkill = await api.getSkill(apiSlug);
+          const depContent = await api.getSkillRaw(apiSlug);
+          const parsedContent = parseSkillMd(depContent);
+          const name = depSkill.name || parsedContent.frontmatter.name || parsed.skill || parsed.name || dep;
+          const description = depSkill.description || parsedContent.frontmatter.description || "";
+          const depDiscovered = {
+            name,
+            description,
+            path: "",
+            // API-only, no local path
+            rawContent: depContent,
+            frontmatter: parsedContent.frontmatter
+          };
+          installedNames.add(normalizeDepKey(name));
+          await installDependencies(depDiscovered);
+          await installOneSkill(depDiscovered, true);
+        } catch (error) {
+          const errorMsg = error instanceof Error ? error.message : "Failed to resolve dependency";
+          for (const agent of targetAgents) {
+            allResults.push({
+              skill: `${dep} (dependency of ${skill.name})`,
+              agent,
+              success: false,
+              error: errorMsg,
+              isDependency: true
+            });
+          }
+        }
+      }
+    }
+    for (const skill of skillsToInstall) {
+      const key = normalizeDepKey(skill.name);
+      if (installedNames.has(key)) continue;
+      installedNames.add(key);
+      await installDependencies(skill);
+      await installOneSkill(skill, false);
+    }
+    spinner2.stop("Installation complete");
+    const successful = allResults.filter((r) => r.success);
+    const failed = allResults.filter((r) => !r.success);
+    if (successful.length > 0) {
+      await saveLastSelectedAgents(targetAgents);
+      const installedSkillNames = new Set(successful.map((r) => r.skill));
+      for (const skillName2 of installedSkillNames) {
+        const discoveredSkill = skillsToInstall.find((s) => s.name === skillName2);
+        const source = sourceParsed.owner && sourceParsed.repo ? `${sourceParsed.owner}/${sourceParsed.repo}` : sourceParsed.localPath || sourceParsed.url;
+        const sourceType = sourceParsed.type === "local" ? "local" : sourceParsed.type;
+        const sourceUrl = sourceParsed.url;
+        let skillPath = "";
+        if (discoveredSkill?.path && tempDir) {
+          const relative2 = discoveredSkill.path.replace(tempDir, "").replace(/^\//, "");
+          if (relative2) skillPath = relative2;
+        } else if (sourceParsed.subpath) {
+          skillPath = sourceParsed.subpath;
+        } else if (sourceParsed.skillFilter) {
+          skillPath = "";
+        }
+        let skillFolderHash = "";
+        if (sourceType === "github" && sourceParsed.owner && sourceParsed.repo) {
+          try {
+            skillFolderHash = await fetchSkillFolderHash(
+              `${sourceParsed.owner}/${sourceParsed.repo}`,
+              skillPath
+            );
+          } catch {
+          }
+        }
+        await addSkillToLock(skillName2, {
+          source,
+          sourceType,
+          sourceUrl,
+          skillPath: skillPath || void 0,
+          skillFolderHash
+        }).catch(() => {
+        });
+      }
+      console.log();
+      const mainSkills = successful.filter((r) => !r.isDependency);
+      const depSkills = successful.filter((r) => r.isDependency);
+      const skillCount = new Set(mainSkills.map((r) => r.skill)).size;
+      const depCount = new Set(depSkills.map((r) => r.skill)).size;
+      const agentCount = new Set(successful.map((r) => r.agent)).size;
+      let message = `Installed ${skillCount} skill(s)`;
+      if (depCount > 0) {
+        message += ` + ${depCount} dependenc${depCount === 1 ? "y" : "ies"}`;
+      }
+      message += ` to ${agentCount} agent(s)`;
+      p.log.success(pc.green(message));
+      const bySkill = successful.reduce((acc, r) => {
+        if (!acc[r.skill]) acc[r.skill] = { agents: [], isDependency: r.isDependency };
+        acc[r.skill].agents.push(r.agent);
+        return acc;
+      }, {});
+      for (const [skill, info] of Object.entries(bySkill)) {
+        const prefix = info.isDependency ? pc.dim("  (dep) ") : "  ";
+        console.log(`${prefix}${pc.green("\u2713")} ${skill}`);
+        for (const agent of info.agents) {
+          const agentName = agents[agent]?.displayName || agent;
+          console.log(`    ${pc.dim("\u2192")} ${agentName}`);
+        }
+      }
+    }
+    if (failed.length > 0) {
+      console.log();
+      p.log.error(pc.red(`Failed for ${failed.length} installation(s)`));
+      for (const r of failed) {
+        const agentName = agents[r.agent]?.displayName || r.agent;
+        console.log(`  ${pc.red("\u2717")} ${r.skill} \u2192 ${agentName}: ${pc.dim(r.error || "Unknown error")}`);
+      }
+    }
+    console.log();
+    p.outro(pc.green("Done!"));
+  } finally {
+    await cleanup();
+  }
+}
+async function runSearch(args) {
+  const query = args.join(" ");
+  console.log();
+  p.intro(pc.bgCyan(pc.black(" askill search ")));
+  const spinner2 = p.spinner();
+  spinner2.start(query ? `Searching for "${query}"...` : "Loading skills...");
+  try {
+    const response = query ? await api.search(query, 20) : await api.listSkills({ limit: 20 });
+    const skills = response.data || [];
+    spinner2.stop(`Found ${skills.length} result(s)`);
+    if (skills.length === 0) {
+      p.log.info("No skills found");
+      p.outro(`Browse all skills at ${pc.cyan("https://askill.sh")}`);
+      return;
+    }
+    console.log();
+    for (const skill of skills) {
+      const displayName = skill.name || "unknown";
+      const owner = skill.owner || "unknown";
+      const description = skill.description || "";
+      console.log(`  ${pc.cyan(displayName)} ${pc.dim(`by ${owner}`)}`);
+      if (description) {
+        console.log(`  ${pc.dim(description.slice(0, 80))}${description.length > 80 ? "..." : ""}`);
+      }
+      const installCmd = skill.owner && skill.repo ? `gh:${skill.owner}/${skill.repo}@${displayName}` : `gh:${displayName}`;
+      console.log(`  ${pc.dim("askill add")} ${installCmd}`);
+      console.log();
+    }
+    p.outro(`Browse more at ${pc.cyan("https://askill.sh")}`);
+  } catch (error) {
+    spinner2.stop(pc.red("Search failed"));
+    if (error instanceof Error) {
+      console.log(pc.red(error.message));
+    }
+    process.exit(1);
+  }
+}
+async function runList(args) {
+  const isGlobal = args.includes("-g") || args.includes("--global");
+  console.log();
+  p.intro(pc.bgCyan(pc.black(" askill list ")));
+  const spinner2 = p.spinner();
+  spinner2.start("Loading installed skills...");
+  const skills = await listInstalledSkills({ global: isGlobal ? true : void 0 });
+  spinner2.stop(`Found ${skills.length} skill(s)`);
+  if (skills.length === 0) {
+    p.log.info("No skills installed");
+    p.outro(`Install skills with ${pc.cyan("askill add <skill>")}`);
+    return;
+  }
+  console.log();
+  for (const skill of skills) {
+    const scope = skill.scope === "global" ? pc.yellow("[global]") : pc.dim("[project]");
+    const agentList = skill.agents.map((a) => agents[a]?.displayName || a).join(", ");
+    console.log(`  ${pc.cyan(skill.name)} ${scope}`);
+    console.log(`  ${pc.dim("Agents:")} ${agentList || pc.dim("none")}`);
+    console.log(`  ${pc.dim(skill.path)}`);
+    console.log();
+  }
+  p.outro("");
+}
+async function runRemove(args) {
+  const isGlobal = args.includes("-g") || args.includes("--global");
+  const skillName = args.find((a) => !a.startsWith("-"));
+  if (!skillName) {
+    console.log(`${RED}Error: Missing skill name${RESET}`);
+    console.log(`Usage: askill remove <skill-name>`);
+    process.exit(1);
+  }
+  console.log();
+  p.intro(pc.bgCyan(pc.black(" askill remove ")));
+  const spinner2 = p.spinner();
+  spinner2.start("Detecting agents...");
+  const installedAgents = await detectInstalledAgents();
+  spinner2.stop(`Found ${installedAgents.length} agent(s)`);
+  const agentsWithSkill = [];
+  for (const agent of installedAgents) {
+    if (await isSkillInstalled(skillName, agent, { global: isGlobal })) {
+      agentsWithSkill.push(agent);
+    }
+  }
+  if (agentsWithSkill.length === 0) {
+    p.log.info(`Skill "${skillName}" not found`);
+    p.outro("");
+    return;
+  }
+  const confirmed = await p.confirm({
+    message: `Remove ${pc.cyan(skillName)} from ${agentsWithSkill.length} agent(s)?`
+  });
+  if (p.isCancel(confirmed) || !confirmed) {
+    p.cancel("Removal cancelled");
+    process.exit(0);
+  }
+  spinner2.start("Removing...");
+  for (const agent of agentsWithSkill) {
+    await removeSkill(skillName, agent, { global: isGlobal });
+  }
+  await removeSkillFromLock(skillName).catch(() => {
+  });
+  spinner2.stop("Removed");
+  p.outro(pc.green(`Removed ${skillName} from ${agentsWithSkill.length} agent(s)`));
+}
+async function runInfo(args) {
+  const skillName = args[0];
+  if (!skillName) {
+    console.log(`${RED}Error: Missing skill name${RESET}`);
+    console.log(`Usage: askill info <skill-name>`);
+    process.exit(1);
+  }
+  console.log();
+  p.intro(pc.bgCyan(pc.black(" askill info ")));
+  const spinner2 = p.spinner();
+  spinner2.start(`Fetching ${skillName}...`);
+  try {
+    const skill = await api.getSkill(skillName);
+    spinner2.stop("");
+    const displayName = skill.name || "unknown";
+    const owner = skill.owner || "unknown";
+    const repo = skill.repo || "";
+    console.log();
+    console.log(`  ${pc.bold(displayName)}`);
+    if (skill.description) {
+      console.log(`  ${pc.dim(skill.description)}`);
+    }
+    console.log();
+    console.log(`  ${pc.dim("Owner:")}      ${owner}`);
+    if (repo) {
+      console.log(`  ${pc.dim("Repository:")} ${owner}/${repo}`);
+    }
+    if (skill.stars !== null && skill.stars !== void 0) {
+      console.log(`  ${pc.dim("Stars:")}      ${skill.stars.toLocaleString()}`);
+    }
+    if (skill.tags && skill.tags.length > 0) {
+      console.log(`  ${pc.dim("Tags:")}       ${skill.tags.join(", ")}`);
+    }
+    if (skill.path) {
+      console.log(`  ${pc.dim("Path:")}       ${skill.path}`);
+    }
+    if (skill.updatedAt) {
+      console.log(`  ${pc.dim("Updated:")}    ${new Date(skill.updatedAt).toLocaleDateString()}`);
+    }
+    console.log();
+    const installCmd = skill.owner && skill.repo ? `${skill.owner}/${skill.repo}@${displayName}` : displayName;
+    console.log(`  ${pc.dim("Install:")}    ${pc.cyan(`askill install gh:${installCmd}`)}`);
+    console.log();
+    p.outro("");
+  } catch (error) {
+    if (error instanceof APIError && error.status === 404) {
+      spinner2.stop(pc.red("Not found"));
+      p.outro(pc.red(`Skill "${skillName}" not found`));
+      process.exit(1);
+    }
+    throw error;
+  }
+}
+async function runCheck(_args) {
+  console.log();
+  p.intro(pc.bgCyan(pc.black(" askill check ")));
+  const spinner2 = p.spinner();
+  spinner2.start("Reading lock file...");
+  const skills = await getAllLockedSkills();
+  const skillNames = Object.keys(skills);
+  if (skillNames.length === 0) {
+    spinner2.stop("No skills tracked");
+    p.log.info("No installed skills found in lock file");
+    p.log.info(`Install skills with ${pc.cyan("askill add <skill>")}`);
+    p.outro("");
+    return;
+  }
+  spinner2.stop(`Found ${skillNames.length} tracked skill(s)`);
+  spinner2.start("Checking for updates...");
+  const updatable = [];
+  const upToDate = [];
+  const uncheckable = [];
+  for (const [name, entry] of Object.entries(skills)) {
+    if (entry.sourceType !== "github" || !entry.source) {
+      uncheckable.push({ name, reason: entry.sourceType === "local" ? "local source" : "no source info" });
+      continue;
+    }
+    if (!entry.skillFolderHash) {
+      uncheckable.push({ name, reason: "no hash recorded (reinstall to fix)" });
+      continue;
+    }
+    try {
+      const remoteHash = await fetchSkillFolderHash(entry.source, entry.skillPath || "");
+      if (!remoteHash) {
+        uncheckable.push({ name, reason: "could not fetch remote hash" });
+        continue;
+      }
+      if (remoteHash !== entry.skillFolderHash) {
+        updatable.push({
+          name,
+          source: entry.source,
+          sourceUrl: entry.sourceUrl,
+          skillPath: entry.skillPath,
+          localHash: entry.skillFolderHash,
+          remoteHash
+        });
+      } else {
+        upToDate.push(name);
+      }
+    } catch {
+      uncheckable.push({ name, reason: "failed to check remote" });
+    }
+  }
+  spinner2.stop("Check complete");
+  console.log();
+  if (updatable.length > 0) {
+    p.log.warning(pc.yellow(`${updatable.length} skill(s) have updates available:`));
+    for (const u of updatable) {
+      console.log(`  ${pc.yellow("\u2191")} ${pc.cyan(u.name)} ${pc.dim(`from ${u.source}`)}`);
+      console.log(`    ${pc.dim(`${u.localHash.slice(0, 8)} \u2192 ${u.remoteHash.slice(0, 8)}`)}`);
+    }
+    console.log();
+    p.log.info(`Run ${pc.cyan("askill update")} to update all`);
+  }
+  if (upToDate.length > 0) {
+    p.log.success(pc.green(`${upToDate.length} skill(s) up to date`));
+  }
+  if (uncheckable.length > 0) {
+    for (const u of uncheckable) {
+      console.log(`  ${pc.dim("?")} ${u.name} ${pc.dim(`(${u.reason})`)}`);
+    }
+  }
+  console.log();
+  p.outro(updatable.length > 0 ? pc.yellow(`${updatable.length} update(s) available`) : pc.green("All up to date"));
+}
+async function runUpdate(args) {
+  const isYes = args.includes("-y") || args.includes("--yes");
+  const specificSkill = args.find((a) => !a.startsWith("-"));
+  console.log();
+  p.intro(pc.bgCyan(pc.black(" askill update ")));
+  const spinner2 = p.spinner();
+  spinner2.start("Checking for updates...");
+  const skills = await getAllLockedSkills();
+  const skillNames = Object.keys(skills);
+  if (skillNames.length === 0) {
+    spinner2.stop("No skills tracked");
+    p.log.info("No installed skills found in lock file");
+    p.outro("");
+    return;
+  }
+  const updatable = [];
+  for (const [name, entry] of Object.entries(skills)) {
+    if (specificSkill && name !== specificSkill) continue;
+    if (entry.sourceType !== "github" || !entry.source || !entry.skillFolderHash) {
+      continue;
+    }
+    try {
+      const remoteHash = await fetchSkillFolderHash(entry.source, entry.skillPath || "");
+      if (remoteHash && remoteHash !== entry.skillFolderHash) {
+        updatable.push({
+          name,
+          source: entry.source,
+          sourceUrl: entry.sourceUrl,
+          skillPath: entry.skillPath,
+          localHash: entry.skillFolderHash,
+          remoteHash
+        });
+      }
+    } catch {
+    }
+  }
+  if (updatable.length === 0) {
+    spinner2.stop("All skills up to date");
+    p.outro(pc.green("Nothing to update"));
+    return;
+  }
+  spinner2.stop(`${updatable.length} update(s) available`);
+  for (const u of updatable) {
+    console.log(`  ${pc.yellow("\u2191")} ${pc.cyan(u.name)} ${pc.dim(`(${u.localHash.slice(0, 8)} \u2192 ${u.remoteHash.slice(0, 8)})`)}`);
+  }
+  if (!isYes) {
+    const confirmed = await p.confirm({
+      message: `Update ${updatable.length} skill(s)?`
+    });
+    if (p.isCancel(confirmed) || !confirmed) {
+      p.cancel("Update cancelled");
+      return;
+    }
+  }
+  const lastAgents = await getLastSelectedAgents();
+  let targetAgents;
+  if (lastAgents && lastAgents.length > 0) {
+    targetAgents = lastAgents;
+  } else {
+    spinner2.start("Detecting agents...");
+    const installedAgents = await detectInstalledAgents();
+    spinner2.stop(`Found ${installedAgents.length} agent(s)`);
+    targetAgents = installedAgents;
+  }
+  if (targetAgents.length === 0) {
+    p.log.error("No agents found");
+    p.outro(pc.red("Cannot update without agents"));
+    return;
+  }
+  spinner2.start("Updating...");
+  let successCount = 0;
+  let failCount = 0;
+  for (const u of updatable) {
+    spinner2.message(`Updating ${u.name}...`);
+    let tempDir;
+    try {
+      tempDir = await cloneRepo(u.sourceUrl);
+      let discovered = await discoverSkills(tempDir, u.skillPath);
+      discovered = discovered.filter((s) => s.name === u.name);
+      if (discovered.length === 0) {
+        discovered = await discoverSkills(tempDir);
+        discovered = discovered.filter((s) => s.name === u.name);
+      }
+      if (discovered.length === 0) {
+        p.log.warning(`Skill "${u.name}" not found in source, skipping`);
+        failCount++;
+        continue;
+      }
+      const skill = discovered[0];
+      for (const agent of targetAgents) {
+        if (skill.path) {
+          await installSkillFromDir(skill.name, skill.path, agent, { mode: "symlink" });
+        } else {
+          await installSkill(skill.name, skill.rawContent, agent, { mode: "symlink" });
+        }
+      }
+      const lockEntry = skills[u.name];
+      await addSkillToLock(u.name, {
+        source: lockEntry.source,
+        sourceType: lockEntry.sourceType,
+        sourceUrl: lockEntry.sourceUrl,
+        skillPath: lockEntry.skillPath,
+        skillFolderHash: u.remoteHash
+      });
+      successCount++;
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : "Unknown error";
+      p.log.error(`Failed to update ${u.name}: ${pc.dim(msg)}`);
+      failCount++;
+    } finally {
+      if (tempDir) {
+        await cleanupTempDir(tempDir).catch(() => {
+        });
+      }
+    }
+  }
+  spinner2.stop("Update complete");
+  if (successCount > 0) {
+    p.log.success(pc.green(`Updated ${successCount} skill(s)`));
+  }
+  if (failCount > 0) {
+    p.log.error(pc.red(`Failed to update ${failCount} skill(s)`));
+  }
+  console.log();
+  p.outro(pc.green("Done!"));
+}
+function parseRunTarget(input) {
+  const colonIndex = input.lastIndexOf(":");
+  if (colonIndex <= 0 || colonIndex === input.length - 1) {
+    return null;
+  }
+  return {
+    skill: input.slice(0, colonIndex),
+    command: input.slice(colonIndex + 1)
+  };
+}
+async function findSkillDir(skillName) {
+  const { access: fsAccess } = await import("fs/promises");
+  const sanitized = sanitizeName(skillName);
+  const cwd = process.cwd();
+  const projectCanonical = join8(cwd, AGENTS_DIR, SKILLS_SUBDIR, sanitized);
+  try {
+    await fsAccess(join8(projectCanonical, "SKILL.md"));
+    return projectCanonical;
+  } catch {
+  }
+  const commonAgentDirs = [".claude/skills", ".cursor/skills", ".opencode/skills", ".windsurf/skills"];
+  for (const dir of commonAgentDirs) {
+    const agentPath = join8(cwd, dir, sanitized);
+    try {
+      await fsAccess(join8(agentPath, "SKILL.md"));
+      return agentPath;
+    } catch {
+    }
+  }
+  const home2 = homedir6();
+  const globalCanonical = join8(home2, AGENTS_DIR, SKILLS_SUBDIR, sanitized);
+  try {
+    await fsAccess(join8(globalCanonical, "SKILL.md"));
+    return globalCanonical;
+  } catch {
+  }
+  const globalAgentDirs = [".claude/skills", ".cursor/skills", ".opencode/skills"];
+  for (const dir of globalAgentDirs) {
+    const agentPath = join8(home2, dir, sanitized);
+    try {
+      await fsAccess(join8(agentPath, "SKILL.md"));
+      return agentPath;
+    } catch {
+    }
+  }
+  return null;
+}
+async function runRun(args) {
+  if (args.length === 0) {
+    console.log(`${RED}Error: Missing run target${RESET}`);
+    console.log(`Usage: askill run <skill>:<command> [args...]`);
+    console.log(`
+Examples:`);
+    console.log(`  askill run my-skill:build`);
+    console.log(`  askill run code-stats:analyze -- --path ./src`);
+    console.log(`  askill run my-skill:_setup`);
+    process.exit(1);
+  }
+  const target = args[0];
+  const parsed = parseRunTarget(target);
+  if (!parsed) {
+    console.log(`${RED}Error: Invalid run target "${target}"${RESET}`);
+    console.log(`Expected format: ${CYAN}<skill>:<command>${RESET}`);
+    console.log(`Example: askill run my-skill:build`);
+    process.exit(1);
+  }
+  const { skill, command } = parsed;
+  let extraArgs = args.slice(1);
+  if (extraArgs[0] === "--") {
+    extraArgs = extraArgs.slice(1);
+  }
+  const skillDir = await findSkillDir(skill);
+  if (!skillDir) {
+    console.log(`${RED}Error: Skill "${skill}" not found${RESET}`);
+    console.log(`Install it with: ${CYAN}askill add <source>${RESET}`);
+    process.exit(1);
+  }
+  const fs = await import("fs/promises");
+  const skillMdPath = join8(skillDir, "SKILL.md");
+  const content = await fs.readFile(skillMdPath, "utf-8");
+  const { frontmatter } = parseSkillMd(content);
+  if (!frontmatter.commands || Object.keys(frontmatter.commands).length === 0) {
+    console.log(`${RED}Error: Skill "${skill}" does not define any commands${RESET}`);
+    console.log(`${DIM}Check the skill's SKILL.md for available commands${RESET}`);
+    process.exit(1);
+  }
+  const cmdDef = frontmatter.commands[command];
+  if (!cmdDef) {
+    console.log(`${RED}Error: Command "${command}" not found in skill "${skill}"${RESET}`);
+    console.log(`
+Available commands:`);
+    for (const [name, def] of Object.entries(frontmatter.commands)) {
+      const prefix = name.startsWith("_") ? pc.dim("  (internal) ") : "  ";
+      console.log(`${prefix}${pc.cyan(name)} ${pc.dim("\u2014")} ${def.description || "No description"}`);
+    }
+    process.exit(1);
+  }
+  if (!cmdDef.run) {
+    console.log(`${RED}Error: Command "${command}" has no "run" field${RESET}`);
+    process.exit(1);
+  }
+  let shellCmd = cmdDef.run;
+  if (extraArgs.length > 0) {
+    const escapedArgs = extraArgs.map((a) => {
+      if (/[^a-zA-Z0-9_\-.\/=:]/.test(a)) {
+        return `'${a.replace(/'/g, "'\\''")}'`;
+      }
+      return a;
+    });
+    shellCmd += " " + escapedArgs.join(" ");
+  }
+  console.log(`${DIM}$ ${shellCmd}${RESET}`);
+  console.log();
+  const { spawn } = await import("child_process");
+  const child = spawn(shellCmd, {
+    cwd: skillDir,
+    shell: true,
+    stdio: "inherit",
+    env: {
+      ...process.env,
+      ASKILL_SKILL_DIR: skillDir,
+      ASKILL_SKILL_NAME: skill,
+      ASKILL_COMMAND: command
+    }
+  });
+  const exitCode = await new Promise((resolve4) => {
+    child.on("close", (code) => resolve4(code ?? 0));
+    child.on("error", () => resolve4(1));
+  });
+  process.exit(exitCode);
+}
+function validateFrontmatter(frontmatter) {
+  const errors = [];
+  const warnings = [];
+  if (!frontmatter.name) {
+    errors.push("Missing required field: name");
+  } else if (typeof frontmatter.name !== "string") {
+    errors.push('Field "name" must be a string');
+  } else if (!/^[a-z0-9-]+$/.test(frontmatter.name)) {
+    errors.push('Field "name" must be lowercase alphanumeric with hyphens only');
+  }
+  if (!frontmatter.description) {
+    errors.push("Missing required field: description");
+  } else if (typeof frontmatter.description !== "string") {
+    errors.push('Field "description" must be a string');
+  } else if (frontmatter.description.length > 200) {
+    warnings.push('Field "description" should be 200 characters or less');
+  }
+  if (frontmatter.version !== void 0) {
+    if (typeof frontmatter.version !== "string") {
+      errors.push('Field "version" must be a string');
+    } else if (!/^\d+\.\d+\.\d+(-[\w.]+)?(\+[\w.]+)?$/.test(frontmatter.version)) {
+      errors.push('Field "version" must be valid semver (e.g., 1.0.0, 1.0.0-beta.1)');
+    }
+  } else {
+    warnings.push("Missing optional field: version (recommended)");
+  }
+  if (frontmatter.author !== void 0) {
+    if (typeof frontmatter.author !== "string" && typeof frontmatter.author !== "object") {
+      errors.push('Field "author" must be a string or object');
+    }
+  }
+  if (frontmatter.tags !== void 0) {
+    if (!Array.isArray(frontmatter.tags)) {
+      errors.push('Field "tags" must be an array');
+    } else {
+      for (const tag of frontmatter.tags) {
+        if (typeof tag !== "string") {
+          errors.push("Each tag must be a string");
+          break;
+        }
+      }
+    }
+  }
+  if (frontmatter.dependencies !== void 0) {
+    if (!Array.isArray(frontmatter.dependencies)) {
+      errors.push('Field "dependencies" must be an array');
+    } else {
+      for (const dep of frontmatter.dependencies) {
+        if (typeof dep !== "string") {
+          errors.push("Each dependency must be a string");
+          break;
+        }
+        if (!dep.startsWith("@") && !dep.startsWith("gh:")) {
+          warnings.push(`Dependency "${dep}" should start with @ or gh:`);
+        }
+      }
+    }
+  }
+  if (frontmatter.commands !== void 0) {
+    if (typeof frontmatter.commands !== "object" || frontmatter.commands === null) {
+      errors.push('Field "commands" must be an object');
+    } else {
+      const commands = frontmatter.commands;
+      for (const [cmdName, cmdDef] of Object.entries(commands)) {
+        if (typeof cmdDef !== "object" || cmdDef === null) {
+          errors.push(`Command "${cmdName}" must be an object`);
+          continue;
+        }
+        const def = cmdDef;
+        if (!def.run) {
+          errors.push(`Command "${cmdName}" is missing required field: run`);
+        } else if (typeof def.run !== "string") {
+          errors.push(`Command "${cmdName}.run" must be a string`);
+        }
+        if (!def.description) {
+          warnings.push(`Command "${cmdName}" is missing description`);
+        } else if (typeof def.description !== "string") {
+          errors.push(`Command "${cmdName}.description" must be a string`);
+        }
+      }
+    }
+  }
+  return {
+    valid: errors.length === 0,
+    errors,
+    warnings
+  };
+}
+async function runValidate(args) {
+  let targetPath = args.find((a) => !a.startsWith("-")) || "SKILL.md";
+  if (!targetPath.endsWith("SKILL.md")) {
+    targetPath = join8(targetPath, "SKILL.md");
+  }
+  const absolutePath = join8(process.cwd(), targetPath);
+  console.log();
+  p.intro(pc.bgCyan(pc.black(" askill validate ")));
+  const spinner2 = p.spinner();
+  spinner2.start(`Checking ${targetPath}...`);
+  const fs = await import("fs/promises");
+  try {
+    await fs.access(absolutePath);
+  } catch {
+    spinner2.stop(pc.red("File not found"));
+    p.log.error(`Cannot find ${pc.cyan(targetPath)}`);
+    p.outro(pc.red("Validation failed"));
+    process.exit(1);
+  }
+  let content;
+  try {
+    content = await fs.readFile(absolutePath, "utf-8");
+  } catch (error) {
+    spinner2.stop(pc.red("Read error"));
+    p.log.error(`Cannot read file: ${error instanceof Error ? error.message : "Unknown error"}`);
+    p.outro(pc.red("Validation failed"));
+    process.exit(1);
+  }
+  const frontmatterMatch = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+  if (!frontmatterMatch) {
+    spinner2.stop(pc.red("Invalid format"));
+    p.log.error("SKILL.md must start with YAML frontmatter (--- ... ---)");
+    p.outro(pc.red("Validation failed"));
+    process.exit(1);
+  }
+  spinner2.stop("Parsing...");
+  const { frontmatter } = parseSkillMd(content);
+  const result = validateFrontmatter(frontmatter);
+  console.log();
+  if (result.errors.length > 0) {
+    for (const error of result.errors) {
+      console.log(`  ${pc.red("\u2717")} ${error}`);
+    }
+  }
+  if (result.warnings.length > 0) {
+    for (const warning of result.warnings) {
+      console.log(`  ${pc.yellow("!")} ${warning}`);
+    }
+  }
+  const checks = [
+    { name: "Frontmatter is valid YAML", passed: true },
+    // Already parsed
+    { name: "Required field: name", passed: !!frontmatter.name && typeof frontmatter.name === "string" },
+    { name: "Required field: description", passed: !!frontmatter.description && typeof frontmatter.description === "string" }
+  ];
+  if (frontmatter.version) {
+    const versionValid = typeof frontmatter.version === "string" && /^\d+\.\d+\.\d+(-[\w.]+)?(\+[\w.]+)?$/.test(frontmatter.version);
+    checks.push({ name: `Version format: ${frontmatter.version}`, passed: versionValid });
+  }
+  if (frontmatter.dependencies && Array.isArray(frontmatter.dependencies)) {
+    checks.push({ name: `Dependencies: ${frontmatter.dependencies.length} defined`, passed: true });
+  }
+  if (frontmatter.commands && typeof frontmatter.commands === "object") {
+    const cmdCount = Object.keys(frontmatter.commands).length;
+    checks.push({ name: `Commands: ${cmdCount} defined`, passed: cmdCount > 0 });
+  }
+  if (result.errors.length === 0) {
+    for (const check of checks) {
+      if (check.passed) {
+        console.log(`  ${pc.green("\u2713")} ${check.name}`);
+      }
+    }
+  }
+  console.log();
+  if (result.valid) {
+    if (result.warnings.length > 0) {
+      p.outro(pc.yellow(`Valid with ${result.warnings.length} warning(s)`));
+    } else {
+      p.outro(pc.green("Ready to publish!"));
+    }
+  } else {
+    p.outro(pc.red(`Validation failed: ${result.errors.length} error(s)`));
+    process.exit(1);
+  }
+}
+async function runInit(args) {
+  const targetDir = args.find((a) => !a.startsWith("-")) || ".";
+  const isYes = args.includes("-y") || args.includes("--yes");
+  console.log();
+  p.intro(pc.bgCyan(pc.black(" askill init ")));
+  const skillPath = join8(process.cwd(), targetDir, "SKILL.md");
+  try {
+    await import("fs").then((fs2) => fs2.promises.access(skillPath));
+    p.log.error(`SKILL.md already exists at ${pc.cyan(skillPath)}`);
+    p.outro(pc.red("Aborted"));
+    return;
+  } catch {
+  }
+  let name;
+  let description;
+  let version;
+  let author;
+  let tags;
+  if (isYes) {
+    const dirName = targetDir === "." ? process.cwd().split("/").pop() || "my-skill" : targetDir;
+    name = dirName;
+    description = "A new askill skill";
+    version = "0.1.0";
+    author = "";
+    tags = [];
+  } else {
+    const dirName = targetDir === "." ? process.cwd().split("/").pop() || "my-skill" : targetDir;
+    const nameResult = await p.text({
+      message: "Skill name",
+      placeholder: dirName,
+      defaultValue: dirName,
+      validate: (value) => {
+        if (!value) return "Name is required";
+        if (!/^[a-z0-9-]+$/.test(value)) return "Name must be lowercase alphanumeric with hyphens";
+        return void 0;
+      }
+    });
+    if (p.isCancel(nameResult)) {
+      p.cancel("Init cancelled");
+      return;
+    }
+    name = nameResult;
+    const descResult = await p.text({
+      message: "Description",
+      placeholder: "What does this skill do?",
+      validate: (value) => {
+        if (!value) return "Description is required";
+        if (value.length > 200) return "Description must be 200 characters or less";
+        return void 0;
+      }
+    });
+    if (p.isCancel(descResult)) {
+      p.cancel("Init cancelled");
+      return;
+    }
+    description = descResult;
+    const versionResult = await p.text({
+      message: "Version",
+      placeholder: "0.1.0",
+      defaultValue: "0.1.0",
+      validate: (value) => {
+        if (!value) return "Version is required";
+        if (!/^\d+\.\d+\.\d+(-[\w.]+)?$/.test(value)) return "Must be valid semver (e.g., 0.1.0)";
+        return void 0;
+      }
+    });
+    if (p.isCancel(versionResult)) {
+      p.cancel("Init cancelled");
+      return;
+    }
+    version = versionResult;
+    const authorResult = await p.text({
+      message: "Author (GitHub username)",
+      placeholder: "your-username"
+    });
+    if (p.isCancel(authorResult)) {
+      p.cancel("Init cancelled");
+      return;
+    }
+    author = authorResult || "";
+    const tagsResult = await p.text({
+      message: "Tags (comma-separated)",
+      placeholder: "automation, productivity"
+    });
+    if (p.isCancel(tagsResult)) {
+      p.cancel("Init cancelled");
+      return;
+    }
+    tags = tagsResult.split(",").map((t) => t.trim()).filter((t) => t.length > 0);
+  }
+  let content = "---\n";
+  content += `name: ${name}
+`;
+  content += `description: ${description}
+`;
+  content += `version: ${version}
+`;
+  if (author) {
+    content += `author: ${author}
+`;
+  }
+  if (tags.length > 0) {
+    content += `tags:
+`;
+    for (const tag of tags) {
+      content += `  - ${tag}
+`;
+    }
+  }
+  content += "---\n\n";
+  content += `# ${name.split("-").map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ")}
+
+`;
+  content += `${description}
+
+`;
+  content += `## Usage
+
+`;
+  content += `Explain how an AI agent should use this skill...
+
+`;
+  content += `## Examples
+
+`;
+  content += `Provide concrete examples of when and how to use this skill.
+`;
+  const targetPath = join8(process.cwd(), targetDir);
+  if (targetDir !== ".") {
+    const fs2 = await import("fs");
+    await fs2.promises.mkdir(targetPath, { recursive: true });
+  }
+  const fs = await import("fs");
+  await fs.promises.writeFile(skillPath, content, "utf-8");
+  p.log.success(`Created ${pc.cyan(skillPath)}`);
+  console.log();
+  console.log(pc.dim("Next steps:"));
+  console.log(`  1. Edit ${pc.cyan("SKILL.md")} to add instructions`);
+  console.log(`  2. Optionally add ${pc.cyan("scripts/")} for commands`);
+  console.log(`  3. Test locally: ${pc.cyan(`askill add ./${targetDir === "." ? "" : targetDir}`)}`);
+  console.log();
+  p.outro(pc.green("Done!"));
+}
+async function main() {
+  const args = process.argv.slice(2);
+  checkForUpdates().catch(() => {
+  });
+  if (args.length === 0) {
+    showBanner();
+    return;
+  }
+  const command = args[0];
+  const restArgs = args.slice(1);
+  switch (command) {
+    case "install":
+    case "i":
+    case "add":
+      await runInstall(restArgs);
+      break;
+    case "search":
+    case "s":
+    case "find":
+      await runSearch(restArgs);
+      break;
+    case "list":
+    case "ls":
+      await runList(restArgs);
+      break;
+    case "remove":
+    case "rm":
+    case "uninstall":
+      await runRemove(restArgs);
+      break;
+    case "info":
+    case "show":
+      await runInfo(restArgs);
+      break;
+    case "check":
+      await runCheck(restArgs);
+      break;
+    case "update":
+    case "upgrade":
+      await runUpdate(restArgs);
+      break;
+    case "self-update":
+      await selfUpdate();
+      break;
+    case "run":
+      await runRun(restArgs);
+      break;
+    case "validate":
+      await runValidate(restArgs);
+      break;
+    case "init":
+      await runInit(restArgs);
+      break;
+    case "--help":
+    case "-h":
+    case "help":
+      showHelp();
+      break;
+    case "--version":
+    case "-v":
+    case "version":
+      console.log(VERSION);
+      break;
+    default:
+      console.log(`${RED}Unknown command: ${command}${RESET}`);
+      console.log(`Run ${CYAN}askill --help${RESET} for usage.`);
+      process.exit(1);
+  }
+}
+main().catch((error) => {
+  console.error(`${RED}Error: ${error.message}${RESET}`);
+  process.exit(1);
+});