skillkit 1.0.0

package/dist/cli.js

@@ -0,0 +1,2124 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/providers/base.ts
+function parseShorthand(source) {
+  const cleaned = source.replace(/^\/+|\/+$/g, "");
+  const parts = cleaned.split("/");
+  if (parts.length < 2) {
+    return null;
+  }
+  const owner = parts[0];
+  const repo = parts[1];
+  const subpath = parts.length > 2 ? parts.slice(2).join("/") : void 0;
+  return { owner, repo, subpath };
+}
+function isLocalPath(source) {
+  return source.startsWith("/") || source.startsWith("./") || source.startsWith("../") || source.startsWith("~/") || source.startsWith(".");
+}
+function isGitUrl(source) {
+  return source.startsWith("git@") || source.startsWith("https://") || source.startsWith("http://") || source.startsWith("ssh://");
+}
+var init_base = __esm({
+  "src/providers/base.ts"() {
+    "use strict";
+  }
+});
+
+// src/core/types.ts
+import { z } from "zod";
+var AgentType, GitProvider, SkillFrontmatter, SkillMetadata, SkillLocation, Skill, SkillkitConfig;
+var init_types = __esm({
+  "src/core/types.ts"() {
+    "use strict";
+    AgentType = z.enum([
+      "claude-code",
+      "codex",
+      "cursor",
+      "antigravity",
+      "opencode",
+      "gemini-cli",
+      "universal"
+    ]);
+    GitProvider = z.enum(["github", "gitlab", "bitbucket", "local"]);
+    SkillFrontmatter = z.object({
+      name: z.string().min(1).max(64).regex(/^[a-z0-9]+(-[a-z0-9]+)*$/, "Skill name must be lowercase alphanumeric with hyphens, no leading/trailing/consecutive hyphens"),
+      description: z.string().min(1).max(1024),
+      license: z.string().optional(),
+      compatibility: z.string().max(500).optional(),
+      metadata: z.record(z.string()).optional(),
+      "allowed-tools": z.string().optional(),
+      version: z.string().optional(),
+      author: z.string().optional(),
+      tags: z.array(z.string()).optional(),
+      agents: z.array(AgentType).optional()
+    });
+    SkillMetadata = z.object({
+      name: z.string(),
+      description: z.string(),
+      source: z.string(),
+      sourceType: GitProvider,
+      subpath: z.string().optional(),
+      installedAt: z.string().datetime(),
+      updatedAt: z.string().datetime().optional(),
+      enabled: z.boolean().default(true),
+      version: z.string().optional(),
+      checksum: z.string().optional()
+    });
+    SkillLocation = z.enum(["project", "global"]);
+    Skill = z.object({
+      name: z.string(),
+      description: z.string(),
+      path: z.string(),
+      location: SkillLocation,
+      metadata: SkillMetadata.optional(),
+      enabled: z.boolean().default(true)
+    });
+    SkillkitConfig = z.object({
+      version: z.literal(1),
+      agent: AgentType.default("universal"),
+      skillsDir: z.string().optional(),
+      enabledSkills: z.array(z.string()).optional(),
+      disabledSkills: z.array(z.string()).optional(),
+      autoSync: z.boolean().default(true)
+    });
+  }
+});
+
+// src/core/skills.ts
+import { existsSync, readdirSync, readFileSync } from "fs";
+import { join, basename } from "path";
+import { parse as parseYaml } from "yaml";
+function discoverSkills(dir) {
+  const skills = [];
+  if (!existsSync(dir)) {
+    return skills;
+  }
+  const entries = readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    const skillPath = join(dir, entry.name);
+    const skillMdPath = join(skillPath, "SKILL.md");
+    if (existsSync(skillMdPath)) {
+      const skill = parseSkill(skillPath);
+      if (skill) {
+        skills.push(skill);
+      }
+    }
+  }
+  return skills;
+}
+function parseSkill(skillPath, location = "project") {
+  const skillMdPath = join(skillPath, "SKILL.md");
+  if (!existsSync(skillMdPath)) {
+    return null;
+  }
+  try {
+    const content = readFileSync(skillMdPath, "utf-8");
+    const frontmatter = extractFrontmatter(content);
+    if (!frontmatter) {
+      const name = basename(skillPath);
+      return {
+        name,
+        description: "No description available",
+        path: skillPath,
+        location,
+        enabled: true
+      };
+    }
+    const parsed = SkillFrontmatter.safeParse(frontmatter);
+    if (!parsed.success) {
+      return {
+        name: frontmatter.name || basename(skillPath),
+        description: frontmatter.description || "No description available",
+        path: skillPath,
+        location,
+        enabled: true
+      };
+    }
+    const metadata = loadMetadata(skillPath);
+    return {
+      name: parsed.data.name,
+      description: parsed.data.description,
+      path: skillPath,
+      location,
+      metadata: metadata ?? void 0,
+      enabled: metadata?.enabled ?? true
+    };
+  } catch {
+    return null;
+  }
+}
+function extractFrontmatter(content) {
+  const match = content.match(/^---\s*\n([\s\S]*?)\n---/);
+  if (!match) {
+    return null;
+  }
+  try {
+    return parseYaml(match[1]);
+  } catch {
+    return null;
+  }
+}
+function loadMetadata(skillPath) {
+  const metadataPath = join(skillPath, ".skillkit.json");
+  if (!existsSync(metadataPath)) {
+    return null;
+  }
+  try {
+    const content = readFileSync(metadataPath, "utf-8");
+    const data = JSON.parse(content);
+    const parsed = SkillMetadata.safeParse(data);
+    return parsed.success ? parsed.data : null;
+  } catch {
+    return null;
+  }
+}
+function readSkillContent(skillPath) {
+  const skillMdPath = join(skillPath, "SKILL.md");
+  if (!existsSync(skillMdPath)) {
+    return null;
+  }
+  try {
+    return readFileSync(skillMdPath, "utf-8");
+  } catch {
+    return null;
+  }
+}
+function findSkill(name, searchDirs) {
+  for (const dir of searchDirs) {
+    if (!existsSync(dir)) continue;
+    const skillPath = join(dir, name);
+    if (existsSync(skillPath)) {
+      const location = dir.includes(process.cwd()) ? "project" : "global";
+      return parseSkill(skillPath, location);
+    }
+  }
+  return null;
+}
+function findAllSkills(searchDirs) {
+  const skills = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const dir of searchDirs) {
+    if (!existsSync(dir)) continue;
+    const location = dir.includes(process.cwd()) ? "project" : "global";
+    const discovered = discoverSkills(dir);
+    for (const skill of discovered) {
+      if (!seen.has(skill.name)) {
+        seen.add(skill.name);
+        skills.push({ ...skill, location });
+      }
+    }
+  }
+  return skills;
+}
+function validateSkill(skillPath) {
+  const errors = [];
+  const warnings = [];
+  const dirName = basename(skillPath);
+  const skillMdPath = join(skillPath, "SKILL.md");
+  if (!existsSync(skillMdPath)) {
+    errors.push("Missing SKILL.md file");
+    return { valid: false, errors };
+  }
+  const content = readFileSync(skillMdPath, "utf-8");
+  const frontmatter = extractFrontmatter(content);
+  if (!frontmatter) {
+    errors.push("Missing YAML frontmatter in SKILL.md");
+    return { valid: false, errors };
+  }
+  const parsed = SkillFrontmatter.safeParse(frontmatter);
+  if (!parsed.success) {
+    for (const issue of parsed.error.issues) {
+      errors.push(`${issue.path.join(".") || "frontmatter"}: ${issue.message}`);
+    }
+  }
+  if (parsed.success) {
+    const data = parsed.data;
+    if (data.name !== dirName) {
+      warnings.push(`name "${data.name}" does not match directory name "${dirName}"`);
+    }
+    if (data.description && data.description.length < 50) {
+      warnings.push("description is short; consider describing what the skill does AND when to use it");
+    }
+  }
+  const bodyContent = content.replace(/^---[\s\S]*?---\s*/, "");
+  const lineCount = bodyContent.split("\n").length;
+  if (lineCount > 500) {
+    warnings.push(`SKILL.md has ${lineCount} lines; consider moving detailed content to references/`);
+  }
+  return { valid: errors.length === 0, errors, warnings };
+}
+function isPathInside(child, parent) {
+  const relative = child.replace(parent, "");
+  return !relative.startsWith("..") && !relative.includes("/..");
+}
+var init_skills = __esm({
+  "src/core/skills.ts"() {
+    "use strict";
+    init_types();
+  }
+});
+
+// src/providers/github.ts
+import { execSync } from "child_process";
+import { existsSync as existsSync2, rmSync } from "fs";
+import { join as join2, basename as basename2 } from "path";
+import { tmpdir } from "os";
+import { randomUUID } from "crypto";
+var GitHubProvider;
+var init_github = __esm({
+  "src/providers/github.ts"() {
+    "use strict";
+    init_base();
+    init_skills();
+    GitHubProvider = class {
+      type = "github";
+      name = "GitHub";
+      baseUrl = "https://github.com";
+      parseSource(source) {
+        if (source.startsWith("https://github.com/")) {
+          const path = source.replace("https://github.com/", "").replace(/\.git$/, "");
+          return parseShorthand(path);
+        }
+        if (source.startsWith("git@github.com:")) {
+          const path = source.replace("git@github.com:", "").replace(/\.git$/, "");
+          return parseShorthand(path);
+        }
+        if (!isGitUrl(source) && !source.includes(":")) {
+          return parseShorthand(source);
+        }
+        return null;
+      }
+      matches(source) {
+        return source.startsWith("https://github.com/") || source.startsWith("git@github.com:") || !isGitUrl(source) && !source.includes(":") && source.includes("/");
+      }
+      getCloneUrl(owner, repo) {
+        return `https://github.com/${owner}/${repo}.git`;
+      }
+      getSshUrl(owner, repo) {
+        return `git@github.com:${owner}/${repo}.git`;
+      }
+      async clone(source, _targetDir, options = {}) {
+        const parsed = this.parseSource(source);
+        if (!parsed) {
+          return { success: false, error: `Invalid GitHub source: ${source}` };
+        }
+        const { owner, repo, subpath } = parsed;
+        const cloneUrl = options.ssh ? this.getSshUrl(owner, repo) : this.getCloneUrl(owner, repo);
+        const tempDir = join2(tmpdir(), `skillkit-${randomUUID()}`);
+        try {
+          const args = ["clone"];
+          if (options.depth) {
+            args.push("--depth", String(options.depth));
+          }
+          if (options.branch) {
+            args.push("--branch", options.branch);
+          }
+          args.push(cloneUrl, tempDir);
+          execSync(`git ${args.join(" ")}`, {
+            stdio: ["pipe", "pipe", "pipe"],
+            encoding: "utf-8"
+          });
+          const searchDir = subpath ? join2(tempDir, subpath) : tempDir;
+          const skills = discoverSkills(searchDir);
+          return {
+            success: true,
+            path: searchDir,
+            tempRoot: tempDir,
+            skills: skills.map((s) => s.name),
+            discoveredSkills: skills.map((s) => ({
+              name: s.name,
+              dirName: basename2(s.path),
+              path: s.path
+            }))
+          };
+        } catch (error) {
+          if (existsSync2(tempDir)) {
+            rmSync(tempDir, { recursive: true, force: true });
+          }
+          const message = error instanceof Error ? error.message : String(error);
+          return { success: false, error: `Failed to clone: ${message}` };
+        }
+      }
+    };
+  }
+});
+
+// src/providers/gitlab.ts
+import { execSync as execSync2 } from "child_process";
+import { existsSync as existsSync3, rmSync as rmSync2 } from "fs";
+import { join as join3, basename as basename3 } from "path";
+import { tmpdir as tmpdir2 } from "os";
+import { randomUUID as randomUUID2 } from "crypto";
+var GitLabProvider;
+var init_gitlab = __esm({
+  "src/providers/gitlab.ts"() {
+    "use strict";
+    init_base();
+    init_skills();
+    GitLabProvider = class {
+      type = "gitlab";
+      name = "GitLab";
+      baseUrl = "https://gitlab.com";
+      parseSource(source) {
+        if (source.startsWith("https://gitlab.com/")) {
+          const path = source.replace("https://gitlab.com/", "").replace(/\.git$/, "");
+          return parseShorthand(path);
+        }
+        if (source.startsWith("git@gitlab.com:")) {
+          const path = source.replace("git@gitlab.com:", "").replace(/\.git$/, "");
+          return parseShorthand(path);
+        }
+        if (source.startsWith("gitlab:")) {
+          return parseShorthand(source.replace("gitlab:", ""));
+        }
+        if (source.startsWith("gitlab.com/")) {
+          return parseShorthand(source.replace("gitlab.com/", ""));
+        }
+        return null;
+      }
+      matches(source) {
+        return source.startsWith("https://gitlab.com/") || source.startsWith("git@gitlab.com:") || source.startsWith("gitlab:") || source.startsWith("gitlab.com/");
+      }
+      getCloneUrl(owner, repo) {
+        return `https://gitlab.com/${owner}/${repo}.git`;
+      }
+      getSshUrl(owner, repo) {
+        return `git@gitlab.com:${owner}/${repo}.git`;
+      }
+      async clone(source, _targetDir, options = {}) {
+        const parsed = this.parseSource(source);
+        if (!parsed) {
+          return { success: false, error: `Invalid GitLab source: ${source}` };
+        }
+        const { owner, repo, subpath } = parsed;
+        const cloneUrl = options.ssh ? this.getSshUrl(owner, repo) : this.getCloneUrl(owner, repo);
+        const tempDir = join3(tmpdir2(), `skillkit-${randomUUID2()}`);
+        try {
+          const args = ["clone"];
+          if (options.depth) {
+            args.push("--depth", String(options.depth));
+          }
+          if (options.branch) {
+            args.push("--branch", options.branch);
+          }
+          args.push(cloneUrl, tempDir);
+          execSync2(`git ${args.join(" ")}`, {
+            stdio: ["pipe", "pipe", "pipe"],
+            encoding: "utf-8"
+          });
+          const searchDir = subpath ? join3(tempDir, subpath) : tempDir;
+          const skills = discoverSkills(searchDir);
+          return {
+            success: true,
+            path: searchDir,
+            tempRoot: tempDir,
+            skills: skills.map((s) => s.name),
+            discoveredSkills: skills.map((s) => ({
+              name: s.name,
+              dirName: basename3(s.path),
+              path: s.path
+            }))
+          };
+        } catch (error) {
+          if (existsSync3(tempDir)) {
+            rmSync2(tempDir, { recursive: true, force: true });
+          }
+          const message = error instanceof Error ? error.message : String(error);
+          return { success: false, error: `Failed to clone: ${message}` };
+        }
+      }
+    };
+  }
+});
+
+// src/providers/bitbucket.ts
+import { execSync as execSync3 } from "child_process";
+import { existsSync as existsSync4, rmSync as rmSync3 } from "fs";
+import { join as join4, basename as basename4 } from "path";
+import { tmpdir as tmpdir3 } from "os";
+import { randomUUID as randomUUID3 } from "crypto";
+var BitbucketProvider;
+var init_bitbucket = __esm({
+  "src/providers/bitbucket.ts"() {
+    "use strict";
+    init_base();
+    init_skills();
+    BitbucketProvider = class {
+      type = "bitbucket";
+      name = "Bitbucket";
+      baseUrl = "https://bitbucket.org";
+      parseSource(source) {
+        if (source.startsWith("https://bitbucket.org/")) {
+          const path = source.replace("https://bitbucket.org/", "").replace(/\.git$/, "");
+          return parseShorthand(path);
+        }
+        if (source.startsWith("git@bitbucket.org:")) {
+          const path = source.replace("git@bitbucket.org:", "").replace(/\.git$/, "");
+          return parseShorthand(path);
+        }
+        if (source.startsWith("bitbucket:")) {
+          return parseShorthand(source.replace("bitbucket:", ""));
+        }
+        if (source.startsWith("bitbucket.org/")) {
+          return parseShorthand(source.replace("bitbucket.org/", ""));
+        }
+        return null;
+      }
+      matches(source) {
+        return source.startsWith("https://bitbucket.org/") || source.startsWith("git@bitbucket.org:") || source.startsWith("bitbucket:") || source.startsWith("bitbucket.org/");
+      }
+      getCloneUrl(owner, repo) {
+        return `https://bitbucket.org/${owner}/${repo}.git`;
+      }
+      getSshUrl(owner, repo) {
+        return `git@bitbucket.org:${owner}/${repo}.git`;
+      }
+      async clone(source, _targetDir, options = {}) {
+        const parsed = this.parseSource(source);
+        if (!parsed) {
+          return { success: false, error: `Invalid Bitbucket source: ${source}` };
+        }
+        const { owner, repo, subpath } = parsed;
+        const cloneUrl = options.ssh ? this.getSshUrl(owner, repo) : this.getCloneUrl(owner, repo);
+        const tempDir = join4(tmpdir3(), `skillkit-${randomUUID3()}`);
+        try {
+          const args = ["clone"];
+          if (options.depth) {
+            args.push("--depth", String(options.depth));
+          }
+          if (options.branch) {
+            args.push("--branch", options.branch);
+          }
+          args.push(cloneUrl, tempDir);
+          execSync3(`git ${args.join(" ")}`, {
+            stdio: ["pipe", "pipe", "pipe"],
+            encoding: "utf-8"
+          });
+          const searchDir = subpath ? join4(tempDir, subpath) : tempDir;
+          const skills = discoverSkills(searchDir);
+          return {
+            success: true,
+            path: searchDir,
+            tempRoot: tempDir,
+            skills: skills.map((s) => s.name),
+            discoveredSkills: skills.map((s) => ({
+              name: s.name,
+              dirName: basename4(s.path),
+              path: s.path
+            }))
+          };
+        } catch (error) {
+          if (existsSync4(tempDir)) {
+            rmSync3(tempDir, { recursive: true, force: true });
+          }
+          const message = error instanceof Error ? error.message : String(error);
+          return { success: false, error: `Failed to clone: ${message}` };
+        }
+      }
+    };
+  }
+});
+
+// src/providers/local.ts
+import { existsSync as existsSync5, statSync, realpathSync } from "fs";
+import { join as join5, resolve, basename as basename5 } from "path";
+import { homedir } from "os";
+var LocalProvider;
+var init_local = __esm({
+  "src/providers/local.ts"() {
+    "use strict";
+    init_base();
+    init_skills();
+    LocalProvider = class {
+      type = "local";
+      name = "Local Filesystem";
+      baseUrl = "";
+      parseSource(source) {
+        if (!isLocalPath(source)) {
+          return null;
+        }
+        let expandedPath = source;
+        if (source.startsWith("~/")) {
+          expandedPath = join5(homedir(), source.slice(2));
+        }
+        const absolutePath = resolve(expandedPath);
+        const dirName = basename5(absolutePath);
+        return {
+          owner: "local",
+          repo: dirName,
+          subpath: absolutePath
+        };
+      }
+      matches(source) {
+        return isLocalPath(source);
+      }
+      getCloneUrl(_owner, _repo) {
+        return "";
+      }
+      getSshUrl(_owner, _repo) {
+        return "";
+      }
+      async clone(source, _targetDir, _options = {}) {
+        const parsed = this.parseSource(source);
+        if (!parsed || !parsed.subpath) {
+          return { success: false, error: `Invalid local path: ${source}` };
+        }
+        const sourcePath = parsed.subpath;
+        if (!existsSync5(sourcePath)) {
+          return { success: false, error: `Path does not exist: ${sourcePath}` };
+        }
+        const stats = statSync(sourcePath);
+        if (!stats.isDirectory()) {
+          return { success: false, error: `Path is not a directory: ${sourcePath}` };
+        }
+        try {
+          let actualPath = sourcePath;
+          try {
+            actualPath = realpathSync(sourcePath);
+          } catch {
+          }
+          const skills = discoverSkills(actualPath);
+          return {
+            success: true,
+            path: actualPath,
+            skills: skills.map((s) => s.name)
+          };
+        } catch (error) {
+          const message = error instanceof Error ? error.message : String(error);
+          return { success: false, error: `Failed to process local path: ${message}` };
+        }
+      }
+    };
+  }
+});
+
+// src/providers/index.ts
+var providers_exports = {};
+__export(providers_exports, {
+  BitbucketProvider: () => BitbucketProvider,
+  GitHubProvider: () => GitHubProvider,
+  GitLabProvider: () => GitLabProvider,
+  LocalProvider: () => LocalProvider,
+  detectProvider: () => detectProvider,
+  getAllProviders: () => getAllProviders,
+  getProvider: () => getProvider,
+  isGitUrl: () => isGitUrl,
+  isLocalPath: () => isLocalPath,
+  parseShorthand: () => parseShorthand,
+  parseSource: () => parseSource
+});
+function getProvider(type) {
+  return providers.find((p) => p.type === type);
+}
+function getAllProviders() {
+  return providers;
+}
+function detectProvider(source) {
+  return providers.find((p) => p.matches(source));
+}
+function parseSource(source) {
+  for (const provider of providers) {
+    if (provider.matches(source)) {
+      const parsed = provider.parseSource(source);
+      if (parsed) {
+        return { provider, ...parsed };
+      }
+    }
+  }
+  return null;
+}
+var providers;
+var init_providers = __esm({
+  "src/providers/index.ts"() {
+    "use strict";
+    init_github();
+    init_gitlab();
+    init_bitbucket();
+    init_local();
+    init_base();
+    init_github();
+    init_gitlab();
+    init_bitbucket();
+    init_local();
+    providers = [
+      new LocalProvider(),
+      new GitLabProvider(),
+      new BitbucketProvider(),
+      new GitHubProvider()
+    ];
+  }
+});
+
+// src/cli.ts
+import { Cli, Builtins } from "clipanion";
+
+// src/commands/install.ts
+init_providers();
+import { existsSync as existsSync14, mkdirSync as mkdirSync2, cpSync, rmSync as rmSync4 } from "fs";
+import { join as join14 } from "path";
+import chalk from "chalk";
+import ora from "ora";
+import { Command, Option } from "clipanion";
+
+// src/core/config.ts
+init_types();
+import { existsSync as existsSync13, readFileSync as readFileSync2, writeFileSync, mkdirSync } from "fs";
+import { join as join13, dirname } from "path";
+import { homedir as homedir7 } from "os";
+import { parse as parseYaml2, stringify as stringifyYaml } from "yaml";
+
+// src/agents/claude-code.ts
+import { existsSync as existsSync6 } from "fs";
+import { join as join6 } from "path";
+import { homedir as homedir2 } from "os";
+
+// src/agents/base.ts
+function createSkillXml(skill) {
+  return `<skill>
+<name>${skill.name}</name>
+<description>${escapeXml(skill.description)}</description>
+<location>${skill.location}</location>
+</skill>`;
+}
+function escapeXml(text) {
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+
+// src/agents/claude-code.ts
+var ClaudeCodeAdapter = class {
+  type = "claude-code";
+  name = "Claude Code";
+  skillsDir = ".claude/skills";
+  configFile = "AGENTS.md";
+  generateConfig(skills) {
+    const enabledSkills = skills.filter((s) => s.enabled);
+    if (enabledSkills.length === 0) {
+      return "";
+    }
+    const skillsXml = enabledSkills.map(createSkillXml).join("\n\n");
+    return `<skills_system priority="1">
+
+## Available Skills
+
+<!-- SKILLS_TABLE_START -->
+<usage>
+When users ask you to perform tasks, check if any of the available skills below can help complete the task more effectively. Skills provide specialized capabilities and domain knowledge.
+
+How to use skills:
+- Invoke: \`skillkit read <skill-name>\` or \`npx skillkit read <skill-name>\`
+- The skill content will load with detailed instructions on how to complete the task
+- Base directory provided in output for resolving bundled resources (references/, scripts/, assets/)
+
+Usage notes:
+- Only use skills listed in <available_skills> below
+- Do not invoke a skill that is already loaded in your context
+- Each skill invocation is stateless
+</usage>
+
+<available_skills>
+
+${skillsXml}
+
+</available_skills>
+<!-- SKILLS_TABLE_END -->
+
+</skills_system>`;
+  }
+  parseConfig(content) {
+    const skillNames = [];
+    const skillRegex = /<name>([^<]+)<\/name>/g;
+    let match;
+    while ((match = skillRegex.exec(content)) !== null) {
+      skillNames.push(match[1].trim());
+    }
+    return skillNames;
+  }
+  getInvokeCommand(skillName) {
+    return `skillkit read ${skillName}`;
+  }
+  async isDetected() {
+    const projectClaude = join6(process.cwd(), ".claude");
+    const globalClaude = join6(homedir2(), ".claude");
+    const claudeMd = join6(process.cwd(), "CLAUDE.md");
+    return existsSync6(projectClaude) || existsSync6(globalClaude) || existsSync6(claudeMd);
+  }
+};
+
+// src/agents/cursor.ts
+import { existsSync as existsSync7 } from "fs";
+import { join as join7 } from "path";
+var CursorAdapter = class {
+  type = "cursor";
+  name = "Cursor";
+  skillsDir = ".cursor/skills";
+  configFile = ".cursorrules";
+  generateConfig(skills) {
+    const enabledSkills = skills.filter((s) => s.enabled);
+    if (enabledSkills.length === 0) {
+      return "";
+    }
+    const skillsList = enabledSkills.map((s) => `- **${s.name}**: ${s.description}`).join("\n");
+    const skillsXml = enabledSkills.map(createSkillXml).join("\n\n");
+    return `# Skills System
+
+You have access to specialized skills that can help complete tasks. Use the skillkit CLI to load skill instructions when needed.
+
+## Available Skills
+
+${skillsList}
+
+## How to Use Skills
+
+When a task matches a skill's description, load it with:
+\`\`\`bash
+skillkit read <skill-name>
+\`\`\`
+
+The skill will provide detailed instructions for completing the task.
+
+<!-- SKILLS_DATA_START -->
+${skillsXml}
+<!-- SKILLS_DATA_END -->
+`;
+  }
+  parseConfig(content) {
+    const skillNames = [];
+    const skillRegex = /<name>([^<]+)<\/name>/g;
+    let match;
+    while ((match = skillRegex.exec(content)) !== null) {
+      skillNames.push(match[1].trim());
+    }
+    return skillNames;
+  }
+  getInvokeCommand(skillName) {
+    return `skillkit read ${skillName}`;
+  }
+  async isDetected() {
+    const cursorRules = join7(process.cwd(), ".cursorrules");
+    const cursorDir = join7(process.cwd(), ".cursor");
+    return existsSync7(cursorRules) || existsSync7(cursorDir);
+  }
+};
+
+// src/agents/codex.ts
+import { existsSync as existsSync8 } from "fs";
+import { join as join8 } from "path";
+import { homedir as homedir3 } from "os";
+var CodexAdapter = class {
+  type = "codex";
+  name = "OpenAI Codex CLI";
+  skillsDir = ".codex/skills";
+  configFile = "AGENTS.md";
+  generateConfig(skills) {
+    const enabledSkills = skills.filter((s) => s.enabled);
+    if (enabledSkills.length === 0) {
+      return "";
+    }
+    const skillsList = enabledSkills.map((s) => `| ${s.name} | ${s.description} | \`skillkit read ${s.name}\` |`).join("\n");
+    return `# Skills
+
+You have access to specialized skills for completing complex tasks.
+
+| Skill | Description | Command |
+|-------|-------------|---------|
+${skillsList}
+
+## Usage
+
+When a task matches a skill's capability, run the command to load detailed instructions:
+
+\`\`\`bash
+skillkit read <skill-name>
+\`\`\`
+
+Skills are loaded on-demand to keep context clean. Only load skills when relevant to the current task.
+`;
+  }
+  parseConfig(content) {
+    const skillNames = [];
+    const tableRegex = /^\|\s*([a-z0-9-]+)\s*\|/gm;
+    let match;
+    while ((match = tableRegex.exec(content)) !== null) {
+      const name = match[1].trim();
+      if (name && name !== "Skill" && name !== "-------") {
+        skillNames.push(name);
+      }
+    }
+    return skillNames;
+  }
+  getInvokeCommand(skillName) {
+    return `skillkit read ${skillName}`;
+  }
+  async isDetected() {
+    const codexDir = join8(process.cwd(), ".codex");
+    const globalCodex = join8(homedir3(), ".codex");
+    return existsSync8(codexDir) || existsSync8(globalCodex);
+  }
+};
+
+// src/agents/gemini-cli.ts
+import { existsSync as existsSync9 } from "fs";
+import { join as join9 } from "path";
+import { homedir as homedir4 } from "os";
+var GeminiCliAdapter = class {
+  type = "gemini-cli";
+  name = "Gemini CLI";
+  skillsDir = ".gemini/skills";
+  configFile = "GEMINI.md";
+  generateConfig(skills) {
+    const enabledSkills = skills.filter((s) => s.enabled);
+    if (enabledSkills.length === 0) {
+      return "";
+    }
+    const skillsJson = enabledSkills.map((s) => ({
+      name: s.name,
+      description: s.description,
+      invoke: `skillkit read ${s.name}`,
+      location: s.location
+    }));
+    return `# Skills Configuration
+
+You have access to specialized skills that extend your capabilities.
+
+## Available Skills
+
+${enabledSkills.map((s) => `### ${s.name}
+${s.description}
+
+Invoke: \`skillkit read ${s.name}\``).join("\n\n")}
+
+## Skills Data
+
+\`\`\`json
+${JSON.stringify(skillsJson, null, 2)}
+\`\`\`
+
+## Usage Instructions
+
+1. When a task matches a skill's description, load it using the invoke command
+2. Skills provide step-by-step instructions for complex tasks
+3. Each skill is self-contained with its own resources
+`;
+  }
+  parseConfig(content) {
+    const skillNames = [];
+    const jsonMatch = content.match(/```json\s*([\s\S]*?)```/);
+    if (jsonMatch) {
+      try {
+        const skills = JSON.parse(jsonMatch[1]);
+        if (Array.isArray(skills)) {
+          skills.forEach((s) => {
+            if (s.name) skillNames.push(s.name);
+          });
+        }
+      } catch {
+      }
+    }
+    if (skillNames.length === 0) {
+      const headerRegex = /^### ([a-z0-9-]+)$/gm;
+      let match;
+      while ((match = headerRegex.exec(content)) !== null) {
+        skillNames.push(match[1].trim());
+      }
+    }
+    return skillNames;
+  }
+  getInvokeCommand(skillName) {
+    return `skillkit read ${skillName}`;
+  }
+  async isDetected() {
+    const geminiMd = join9(process.cwd(), "GEMINI.md");
+    const geminiDir = join9(process.cwd(), ".gemini");
+    const globalGemini = join9(homedir4(), ".gemini");
+    return existsSync9(geminiMd) || existsSync9(geminiDir) || existsSync9(globalGemini);
+  }
+};
+
+// src/agents/opencode.ts
+import { existsSync as existsSync10 } from "fs";
+import { join as join10 } from "path";
+import { homedir as homedir5 } from "os";
+var OpenCodeAdapter = class {
+  type = "opencode";
+  name = "OpenCode";
+  skillsDir = ".opencode/skills";
+  configFile = "AGENTS.md";
+  generateConfig(skills) {
+    const enabledSkills = skills.filter((s) => s.enabled);
+    if (enabledSkills.length === 0) {
+      return "";
+    }
+    const skillsXml = enabledSkills.map(createSkillXml).join("\n\n");
+    return `<!-- SKILLKIT_START -->
+# Skills
+
+The following skills are available to help complete tasks:
+
+<skills>
+${skillsXml}
+</skills>
+
+## How to Use
+
+When a task matches a skill's description:
+
+\`\`\`bash
+skillkit read <skill-name>
+\`\`\`
+
+This loads the skill's instructions into context.
+
+<!-- SKILLKIT_END -->`;
+  }
+  parseConfig(content) {
+    const skillNames = [];
+    const skillRegex = /<name>([^<]+)<\/name>/g;
+    let match;
+    while ((match = skillRegex.exec(content)) !== null) {
+      skillNames.push(match[1].trim());
+    }
+    return skillNames;
+  }
+  getInvokeCommand(skillName) {
+    return `skillkit read ${skillName}`;
+  }
+  async isDetected() {
+    const opencodeDir = join10(process.cwd(), ".opencode");
+    const globalOpencode = join10(homedir5(), ".opencode");
+    return existsSync10(opencodeDir) || existsSync10(globalOpencode);
+  }
+};
+
+// src/agents/antigravity.ts
+import { existsSync as existsSync11 } from "fs";
+import { join as join11 } from "path";
+import { homedir as homedir6 } from "os";
+var AntigravityAdapter = class {
+  type = "antigravity";
+  name = "Antigravity";
+  skillsDir = ".antigravity/skills";
+  configFile = "AGENTS.md";
+  generateConfig(skills) {
+    const enabledSkills = skills.filter((s) => s.enabled);
+    if (enabledSkills.length === 0) {
+      return "";
+    }
+    const skillsYaml = enabledSkills.map((s) => `  - name: ${s.name}
+    description: "${s.description}"
+    invoke: skillkit read ${s.name}`).join("\n");
+    return `# Antigravity Skills Configuration
+
+<!-- skills:
+${skillsYaml}
+-->
+
+## Available Skills
+
+${enabledSkills.map((s) => `### ${s.name}
+
+${s.description}
+
+**Usage:** \`skillkit read ${s.name}\`
+`).join("\n")}
+
+## How Skills Work
+
+1. Skills provide specialized knowledge for specific tasks
+2. Load a skill when the current task matches its description
+3. Skills are loaded on-demand to preserve context window
+`;
+  }
+  parseConfig(content) {
+    const skillNames = [];
+    const yamlMatch = content.match(/<!-- skills:\s*([\s\S]*?)-->/);
+    if (yamlMatch) {
+      const nameRegex = /name:\s*([a-z0-9-]+)/g;
+      let match;
+      while ((match = nameRegex.exec(yamlMatch[1])) !== null) {
+        skillNames.push(match[1].trim());
+      }
+    }
+    if (skillNames.length === 0) {
+      const headerRegex = /^### ([a-z0-9-]+)$/gm;
+      let match;
+      while ((match = headerRegex.exec(content)) !== null) {
+        skillNames.push(match[1].trim());
+      }
+    }
+    return skillNames;
+  }
+  getInvokeCommand(skillName) {
+    return `skillkit read ${skillName}`;
+  }
+  async isDetected() {
+    const agDir = join11(process.cwd(), ".antigravity");
+    const globalAg = join11(homedir6(), ".antigravity");
+    return existsSync11(agDir) || existsSync11(globalAg);
+  }
+};
+
+// src/agents/universal.ts
+import { existsSync as existsSync12 } from "fs";
+import { join as join12 } from "path";
+var UniversalAdapter = class {
+  type = "universal";
+  name = "Universal (Any Agent)";
+  skillsDir = ".agent/skills";
+  configFile = "AGENTS.md";
+  generateConfig(skills) {
+    const enabledSkills = skills.filter((s) => s.enabled);
+    if (enabledSkills.length === 0) {
+      return "";
+    }
+    const skillsXml = enabledSkills.map(createSkillXml).join("\n\n");
+    const skillsList = enabledSkills.map((s) => `- **${s.name}**: ${s.description}`).join("\n");
+    return `# Skills System
+
+<!-- SKILLKIT_SKILLS_START -->
+
+## Available Skills
+
+${skillsList}
+
+## How to Use Skills
+
+When a task matches one of the available skills, load it to get detailed instructions:
+
+\`\`\`bash
+skillkit read <skill-name>
+\`\`\`
+
+Or with npx:
+
+\`\`\`bash
+npx skillkit read <skill-name>
+\`\`\`
+
+## Skills Data
+
+<skills_system>
+<usage>
+Skills provide specialized capabilities and domain knowledge.
+- Invoke: \`skillkit read <skill-name>\`
+- Base directory provided in output for resolving resources
+- Only use skills listed below
+- Each invocation is stateless
+</usage>
+
+<available_skills>
+
+${skillsXml}
+
+</available_skills>
+</skills_system>
+
+<!-- SKILLKIT_SKILLS_END -->
+`;
+  }
+  parseConfig(content) {
+    const skillNames = [];
+    const skillRegex = /<name>([^<]+)<\/name>/g;
+    let match;
+    while ((match = skillRegex.exec(content)) !== null) {
+      skillNames.push(match[1].trim());
+    }
+    if (skillNames.length === 0) {
+      const listRegex = /^- \*\*([a-z0-9-]+)\*\*:/gm;
+      while ((match = listRegex.exec(content)) !== null) {
+        skillNames.push(match[1].trim());
+      }
+    }
+    return skillNames;
+  }
+  getInvokeCommand(skillName) {
+    return `skillkit read ${skillName}`;
+  }
+  async isDetected() {
+    const agentDir = join12(process.cwd(), ".agent");
+    const agentsMd = join12(process.cwd(), "AGENTS.md");
+    return existsSync12(agentDir) || existsSync12(agentsMd);
+  }
+};
+
+// src/agents/index.ts
+var adapters = {
+  "claude-code": new ClaudeCodeAdapter(),
+  cursor: new CursorAdapter(),
+  codex: new CodexAdapter(),
+  "gemini-cli": new GeminiCliAdapter(),
+  opencode: new OpenCodeAdapter(),
+  antigravity: new AntigravityAdapter(),
+  universal: new UniversalAdapter()
+};
+function getAdapter(type) {
+  return adapters[type];
+}
+function getAllAdapters() {
+  return Object.values(adapters);
+}
+async function detectAgent() {
+  const checkOrder = [
+    "claude-code",
+    "cursor",
+    "codex",
+    "gemini-cli",
+    "opencode",
+    "antigravity",
+    "universal"
+  ];
+  for (const type of checkOrder) {
+    const adapter = adapters[type];
+    if (await adapter.isDetected()) {
+      return type;
+    }
+  }
+  return "universal";
+}
+
+// src/core/config.ts
+var CONFIG_FILE = "skillkit.yaml";
+var METADATA_FILE = ".skillkit.json";
+function getProjectConfigPath() {
+  return join13(process.cwd(), CONFIG_FILE);
+}
+function getGlobalConfigPath() {
+  return join13(homedir7(), ".config", "skillkit", CONFIG_FILE);
+}
+function loadConfig() {
+  const projectPath = getProjectConfigPath();
+  const globalPath = getGlobalConfigPath();
+  if (existsSync13(projectPath)) {
+    try {
+      const content = readFileSync2(projectPath, "utf-8");
+      const data = parseYaml2(content);
+      const parsed = SkillkitConfig.safeParse(data);
+      if (parsed.success) {
+        return parsed.data;
+      }
+    } catch {
+    }
+  }
+  if (existsSync13(globalPath)) {
+    try {
+      const content = readFileSync2(globalPath, "utf-8");
+      const data = parseYaml2(content);
+      const parsed = SkillkitConfig.safeParse(data);
+      if (parsed.success) {
+        return parsed.data;
+      }
+    } catch {
+    }
+  }
+  return {
+    version: 1,
+    agent: "universal",
+    autoSync: true
+  };
+}
+function saveConfig(config, global = false) {
+  const configPath = global ? getGlobalConfigPath() : getProjectConfigPath();
+  const dir = dirname(configPath);
+  if (!existsSync13(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  const content = stringifyYaml(config);
+  writeFileSync(configPath, content, "utf-8");
+}
+function getSearchDirs(agentType) {
+  const type = agentType || loadConfig().agent;
+  const adapter = getAdapter(type);
+  const dirs = [];
+  dirs.push(join13(process.cwd(), adapter.skillsDir));
+  dirs.push(join13(process.cwd(), ".agent", "skills"));
+  dirs.push(join13(homedir7(), adapter.skillsDir));
+  dirs.push(join13(homedir7(), ".agent", "skills"));
+  return dirs;
+}
+function getInstallDir(global = false, agentType) {
+  const type = agentType || loadConfig().agent;
+  const adapter = getAdapter(type);
+  if (global) {
+    return join13(homedir7(), adapter.skillsDir);
+  }
+  return join13(process.cwd(), adapter.skillsDir);
+}
+function getAgentConfigPath(agentType) {
+  const type = agentType || loadConfig().agent;
+  const adapter = getAdapter(type);
+  return join13(process.cwd(), adapter.configFile);
+}
+function saveSkillMetadata(skillPath, metadata) {
+  const metadataPath = join13(skillPath, METADATA_FILE);
+  writeFileSync(metadataPath, JSON.stringify(metadata, null, 2), "utf-8");
+}
+function loadSkillMetadata(skillPath) {
+  const metadataPath = join13(skillPath, METADATA_FILE);
+  if (!existsSync13(metadataPath)) {
+    return null;
+  }
+  try {
+    const content = readFileSync2(metadataPath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+function setSkillEnabled(skillPath, enabled) {
+  const metadata = loadSkillMetadata(skillPath);
+  if (!metadata) {
+    return false;
+  }
+  metadata.enabled = enabled;
+  metadata.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  saveSkillMetadata(skillPath, metadata);
+  return true;
+}
+async function initProject(agentType) {
+  const type = agentType || await detectAgent();
+  const adapter = getAdapter(type);
+  const skillsDir = join13(process.cwd(), adapter.skillsDir);
+  if (!existsSync13(skillsDir)) {
+    mkdirSync(skillsDir, { recursive: true });
+  }
+  const config = {
+    version: 1,
+    agent: type,
+    autoSync: true
+  };
+  saveConfig(config);
+  const agentConfigPath = join13(process.cwd(), adapter.configFile);
+  if (!existsSync13(agentConfigPath)) {
+    writeFileSync(agentConfigPath, `# ${adapter.name} Configuration
+
+`, "utf-8");
+  }
+}
+
+// src/commands/install.ts
+init_skills();
+var InstallCommand = class extends Command {
+  static paths = [["install"], ["i"]];
+  static usage = Command.Usage({
+    description: "Install skills from GitHub, GitLab, Bitbucket, or local path",
+    examples: [
+      ["Install from GitHub", "$0 install owner/repo"],
+      ["Install from GitLab", "$0 install gitlab:owner/repo"],
+      ["Install from Bitbucket", "$0 install bitbucket:owner/repo"],
+      ["Install specific skills (CI/CD)", "$0 install owner/repo --skills=pdf,xlsx"],
+      ["Install all skills non-interactively", "$0 install owner/repo --all"],
+      ["Install from local path", "$0 install ./my-skills"],
+      ["Install globally", "$0 install owner/repo --global"]
+    ]
+  });
+  source = Option.String({ required: true });
+  skills = Option.String("--skills,-s", {
+    description: "Comma-separated list of skills to install (non-interactive)"
+  });
+  all = Option.Boolean("--all,-a", false, {
+    description: "Install all discovered skills (non-interactive)"
+  });
+  yes = Option.Boolean("--yes,-y", false, {
+    description: "Skip confirmation prompts"
+  });
+  global = Option.Boolean("--global,-g", false, {
+    description: "Install to global skills directory"
+  });
+  force = Option.Boolean("--force,-f", false, {
+    description: "Overwrite existing skills"
+  });
+  provider = Option.String("--provider,-p", {
+    description: "Force specific provider (github, gitlab, bitbucket)"
+  });
+  async execute() {
+    const spinner = ora();
+    try {
+      let providerAdapter = detectProvider(this.source);
+      if (this.provider) {
+        const { getProvider: getProvider2 } = await Promise.resolve().then(() => (init_providers(), providers_exports));
+        providerAdapter = getProvider2(this.provider);
+      }
+      if (!providerAdapter) {
+        console.error(chalk.red(`Could not detect provider for: ${this.source}`));
+        console.error(chalk.dim("Use --provider flag or specify source as:"));
+        console.error(chalk.dim("  GitHub: owner/repo or https://github.com/owner/repo"));
+        console.error(chalk.dim("  GitLab: gitlab:owner/repo or https://gitlab.com/owner/repo"));
+        console.error(chalk.dim("  Bitbucket: bitbucket:owner/repo"));
+        console.error(chalk.dim("  Local: ./path or ~/path"));
+        return 1;
+      }
+      spinner.start(`Fetching from ${providerAdapter.name}...`);
+      const result = await providerAdapter.clone(this.source, "", { depth: 1 });
+      if (!result.success || !result.path) {
+        spinner.fail(chalk.red(result.error || "Failed to fetch source"));
+        return 1;
+      }
+      spinner.succeed(`Found ${result.skills?.length || 0} skill(s)`);
+      const discoveredSkills = result.discoveredSkills || [];
+      let skillsToInstall = discoveredSkills;
+      if (this.skills) {
+        const requestedSkills = this.skills.split(",").map((s) => s.trim());
+        const available = discoveredSkills.map((s) => s.name);
+        const notFound = requestedSkills.filter((s) => !available.includes(s));
+        if (notFound.length > 0) {
+          console.error(chalk.red(`Skills not found: ${notFound.join(", ")}`));
+          console.error(chalk.dim(`Available: ${available.join(", ")}`));
+          return 1;
+        }
+        skillsToInstall = discoveredSkills.filter((s) => requestedSkills.includes(s.name));
+      } else if (this.all || this.yes) {
+        skillsToInstall = discoveredSkills;
+      } else {
+        skillsToInstall = discoveredSkills;
+        if (skillsToInstall.length > 0) {
+          console.log(chalk.cyan("\nSkills to install:"));
+          skillsToInstall.forEach((s) => console.log(chalk.dim(`  - ${s.name}`)));
+          console.log();
+        }
+      }
+      if (skillsToInstall.length === 0) {
+        console.log(chalk.yellow("No skills to install"));
+        return 0;
+      }
+      const installDir = getInstallDir(this.global);
+      if (!existsSync14(installDir)) {
+        mkdirSync2(installDir, { recursive: true });
+      }
+      let installed = 0;
+      for (const skill of skillsToInstall) {
+        const skillName = skill.name;
+        const sourcePath = skill.path;
+        const targetPath = join14(installDir, skillName);
+        if (existsSync14(targetPath) && !this.force) {
+          console.log(chalk.yellow(`  Skipping ${skillName} (already exists, use --force to overwrite)`));
+          continue;
+        }
+        const securityRoot = result.tempRoot || result.path;
+        if (!isPathInside(sourcePath, securityRoot)) {
+          console.log(chalk.red(`  Skipping ${skillName} (path traversal detected)`));
+          continue;
+        }
+        spinner.start(`Installing ${skillName}...`);
+        try {
+          if (existsSync14(targetPath)) {
+            rmSync4(targetPath, { recursive: true, force: true });
+          }
+          cpSync(sourcePath, targetPath, { recursive: true, dereference: true });
+          const metadata = {
+            name: skillName,
+            description: "",
+            source: this.source,
+            sourceType: providerAdapter.type,
+            subpath: skillName,
+            installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+            enabled: true
+          };
+          saveSkillMetadata(targetPath, metadata);
+          spinner.succeed(chalk.green(`Installed ${skillName}`));
+          installed++;
+        } catch (error) {
+          spinner.fail(chalk.red(`Failed to install ${skillName}`));
+          console.error(chalk.dim(error instanceof Error ? error.message : String(error)));
+        }
+      }
+      const cleanupPath = result.tempRoot || result.path;
+      if (!isLocalPath(this.source) && cleanupPath && existsSync14(cleanupPath)) {
+        rmSync4(cleanupPath, { recursive: true, force: true });
+      }
+      console.log();
+      console.log(chalk.green(`Installed ${installed} skill(s) to ${installDir}`));
+      if (!this.yes) {
+        console.log(chalk.dim("\nRun `skillkit sync` to update your agent config"));
+      }
+      return 0;
+    } catch (error) {
+      spinner.fail(chalk.red("Installation failed"));
+      console.error(chalk.dim(error instanceof Error ? error.message : String(error)));
+      return 1;
+    }
+  }
+};
+
+// src/commands/sync.ts
+import { existsSync as existsSync15, readFileSync as readFileSync3, writeFileSync as writeFileSync2, mkdirSync as mkdirSync3 } from "fs";
+import { dirname as dirname2 } from "path";
+import chalk2 from "chalk";
+import { Command as Command2, Option as Option2 } from "clipanion";
+init_skills();
+var SyncCommand = class extends Command2 {
+  static paths = [["sync"], ["s"]];
+  static usage = Command2.Usage({
+    description: "Sync skills to agent configuration file",
+    examples: [
+      ["Sync all enabled skills", "$0 sync"],
+      ["Sync to specific file", "$0 sync --output AGENTS.md"],
+      ["Sync for specific agent", "$0 sync --agent cursor"],
+      ["Only sync enabled skills", "$0 sync --enabled-only"]
+    ]
+  });
+  output = Option2.String("--output,-o", {
+    description: "Output file path (default: agent-specific config file)"
+  });
+  agent = Option2.String("--agent,-a", {
+    description: "Target agent type (claude-code, cursor, codex, etc.)"
+  });
+  enabledOnly = Option2.Boolean("--enabled-only,-e", true, {
+    description: "Only include enabled skills (default: true)"
+  });
+  yes = Option2.Boolean("--yes,-y", false, {
+    description: "Skip confirmation prompts"
+  });
+  async execute() {
+    try {
+      let agentType;
+      if (this.agent) {
+        agentType = this.agent;
+      } else {
+        const config2 = loadConfig();
+        agentType = config2.agent || await detectAgent();
+      }
+      const adapter = getAdapter(agentType);
+      const outputPath = this.output || getAgentConfigPath(agentType);
+      const searchDirs = getSearchDirs(agentType);
+      let skills = findAllSkills(searchDirs);
+      if (this.enabledOnly) {
+        skills = skills.filter((s) => s.enabled);
+      }
+      if (skills.length === 0) {
+        console.log(chalk2.yellow("No skills found to sync"));
+        console.log(chalk2.dim("Install skills with: skillkit install <source>"));
+        return 0;
+      }
+      console.log(chalk2.cyan(`Syncing ${skills.length} skill(s) for ${adapter.name}:`));
+      skills.forEach((s) => {
+        const status = s.enabled ? chalk2.green("\u2713") : chalk2.dim("\u25CB");
+        const location = s.location === "project" ? chalk2.blue("[project]") : chalk2.dim("[global]");
+        console.log(`  ${status} ${s.name} ${location}`);
+      });
+      console.log();
+      const config = adapter.generateConfig(skills);
+      if (!config) {
+        console.log(chalk2.yellow("No configuration generated"));
+        return 0;
+      }
+      let existingContent = "";
+      if (existsSync15(outputPath)) {
+        existingContent = readFileSync3(outputPath, "utf-8");
+      }
+      const newContent = updateConfigContent(existingContent, config, agentType);
+      const dir = dirname2(outputPath);
+      if (!existsSync15(dir)) {
+        mkdirSync3(dir, { recursive: true });
+      }
+      writeFileSync2(outputPath, newContent, "utf-8");
+      console.log(chalk2.green(`Synced to ${outputPath}`));
+      console.log(chalk2.dim(`Agent: ${adapter.name}`));
+      return 0;
+    } catch (error) {
+      console.error(chalk2.red("Sync failed"));
+      console.error(chalk2.dim(error instanceof Error ? error.message : String(error)));
+      return 1;
+    }
+  }
+};
+function updateConfigContent(existing, newConfig, agentType) {
+  const markers = {
+    "claude-code": {
+      start: "<!-- SKILLS_TABLE_START -->",
+      end: "<!-- SKILLS_TABLE_END -->"
+    },
+    cursor: {
+      start: "<!-- SKILLS_DATA_START -->",
+      end: "<!-- SKILLS_DATA_END -->"
+    },
+    universal: {
+      start: "<!-- SKILLKIT_SKILLS_START -->",
+      end: "<!-- SKILLKIT_SKILLS_END -->"
+    }
+  };
+  const agentMarkers = markers[agentType] || markers.universal;
+  const startIdx = existing.indexOf(agentMarkers.start);
+  const endIdx = existing.indexOf(agentMarkers.end);
+  if (startIdx !== -1 && endIdx !== -1) {
+    return existing.slice(0, startIdx) + newConfig.slice(newConfig.indexOf(agentMarkers.start)) + existing.slice(endIdx + agentMarkers.end.length);
+  }
+  const genericStart = "<!-- SKILLKIT_SKILLS_START -->";
+  const genericEnd = "<!-- SKILLKIT_SKILLS_END -->";
+  const gStartIdx = existing.indexOf(genericStart);
+  const gEndIdx = existing.indexOf(genericEnd);
+  if (gStartIdx !== -1 && gEndIdx !== -1) {
+    return existing.slice(0, gStartIdx) + newConfig + existing.slice(gEndIdx + genericEnd.length);
+  }
+  if (existing.trim()) {
+    return existing + "\n\n" + newConfig;
+  }
+  return newConfig;
+}
+
+// src/commands/read.ts
+import chalk3 from "chalk";
+import { Command as Command3, Option as Option3 } from "clipanion";
+init_skills();
+var ReadCommand = class extends Command3 {
+  static paths = [["read"], ["r"]];
+  static usage = Command3.Usage({
+    description: "Read skill content for AI agent consumption",
+    examples: [
+      ["Read a single skill", "$0 read pdf"],
+      ["Read multiple skills", "$0 read pdf,xlsx,docx"],
+      ["Read with verbose output", "$0 read pdf --verbose"]
+    ]
+  });
+  skills = Option3.String({ required: true });
+  verbose = Option3.Boolean("--verbose,-v", false, {
+    description: "Show additional information"
+  });
+  async execute() {
+    const searchDirs = getSearchDirs();
+    const skillNames = this.skills.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
+    if (skillNames.length === 0) {
+      console.error(chalk3.red("No skill names provided"));
+      return 1;
+    }
+    let exitCode = 0;
+    for (const skillName of skillNames) {
+      const skill = findSkill(skillName, searchDirs);
+      if (!skill) {
+        console.error(chalk3.red(`Skill not found: ${skillName}`));
+        console.error(chalk3.dim("Available directories:"));
+        searchDirs.forEach((d) => console.error(chalk3.dim(`  - ${d}`)));
+        exitCode = 1;
+        continue;
+      }
+      if (!skill.enabled) {
+        console.error(chalk3.yellow(`Skill disabled: ${skillName}`));
+        console.error(chalk3.dim("Enable with: skillkit enable " + skillName));
+        exitCode = 1;
+        continue;
+      }
+      const content = readSkillContent(skill.path);
+      if (!content) {
+        console.error(chalk3.red(`Could not read SKILL.md for: ${skillName}`));
+        exitCode = 1;
+        continue;
+      }
+      console.log(`Reading: ${skillName}`);
+      console.log(`Base directory: ${skill.path}`);
+      console.log();
+      console.log(content);
+      console.log();
+      console.log(`Skill read: ${skillName}`);
+      if (skillNames.length > 1 && skillName !== skillNames[skillNames.length - 1]) {
+        console.log("\n---\n");
+      }
+    }
+    return exitCode;
+  }
+};
+
+// src/commands/list.ts
+import chalk4 from "chalk";
+import { Command as Command4, Option as Option4 } from "clipanion";
+init_skills();
+var ListCommand = class extends Command4 {
+  static paths = [["list"], ["ls"], ["l"]];
+  static usage = Command4.Usage({
+    description: "List all installed skills",
+    examples: [
+      ["List all skills", "$0 list"],
+      ["Show only enabled skills", "$0 list --enabled"],
+      ["Show JSON output", "$0 list --json"]
+    ]
+  });
+  enabled = Option4.Boolean("--enabled,-e", false, {
+    description: "Show only enabled skills"
+  });
+  disabled = Option4.Boolean("--disabled,-d", false, {
+    description: "Show only disabled skills"
+  });
+  json = Option4.Boolean("--json,-j", false, {
+    description: "Output as JSON"
+  });
+  async execute() {
+    const searchDirs = getSearchDirs();
+    let skills = findAllSkills(searchDirs);
+    if (this.enabled) {
+      skills = skills.filter((s) => s.enabled);
+    } else if (this.disabled) {
+      skills = skills.filter((s) => !s.enabled);
+    }
+    skills.sort((a, b) => {
+      if (a.location !== b.location) {
+        return a.location === "project" ? -1 : 1;
+      }
+      return a.name.localeCompare(b.name);
+    });
+    if (this.json) {
+      console.log(JSON.stringify(skills, null, 2));
+      return 0;
+    }
+    if (skills.length === 0) {
+      console.log(chalk4.yellow("No skills installed"));
+      console.log(chalk4.dim("Install skills with: skillkit install <source>"));
+      return 0;
+    }
+    console.log(chalk4.cyan(`Installed skills (${skills.length}):
+`));
+    const projectSkills = skills.filter((s) => s.location === "project");
+    const globalSkills = skills.filter((s) => s.location === "global");
+    if (projectSkills.length > 0) {
+      console.log(chalk4.blue("Project skills:"));
+      for (const skill of projectSkills) {
+        printSkill(skill);
+      }
+      console.log();
+    }
+    if (globalSkills.length > 0) {
+      console.log(chalk4.dim("Global skills:"));
+      for (const skill of globalSkills) {
+        printSkill(skill);
+      }
+      console.log();
+    }
+    const enabledCount = skills.filter((s) => s.enabled).length;
+    const disabledCount = skills.length - enabledCount;
+    console.log(
+      chalk4.dim(
+        `${projectSkills.length} project, ${globalSkills.length} global` + (disabledCount > 0 ? `, ${disabledCount} disabled` : "")
+      )
+    );
+    return 0;
+  }
+};
+function printSkill(skill) {
+  const status = skill.enabled ? chalk4.green("\u2713") : chalk4.red("\u25CB");
+  const name = skill.enabled ? skill.name : chalk4.dim(skill.name);
+  const desc = chalk4.dim(truncate(skill.description, 50));
+  console.log(`  ${status} ${name}`);
+  if (skill.description) {
+    console.log(`    ${desc}`);
+  }
+}
+function truncate(str, maxLen) {
+  if (str.length <= maxLen) return str;
+  return str.slice(0, maxLen - 3) + "...";
+}
+
+// src/commands/enable.ts
+import chalk5 from "chalk";
+import { Command as Command5, Option as Option5 } from "clipanion";
+init_skills();
+var EnableCommand = class extends Command5 {
+  static paths = [["enable"]];
+  static usage = Command5.Usage({
+    description: "Enable one or more skills",
+    examples: [
+      ["Enable a skill", "$0 enable pdf"],
+      ["Enable multiple skills", "$0 enable pdf xlsx docx"]
+    ]
+  });
+  skills = Option5.Rest({ required: 1 });
+  async execute() {
+    const searchDirs = getSearchDirs();
+    let success = 0;
+    let failed = 0;
+    for (const skillName of this.skills) {
+      const skill = findSkill(skillName, searchDirs);
+      if (!skill) {
+        console.log(chalk5.red(`Skill not found: ${skillName}`));
+        failed++;
+        continue;
+      }
+      if (skill.enabled) {
+        console.log(chalk5.dim(`Already enabled: ${skillName}`));
+        continue;
+      }
+      const result = setSkillEnabled(skill.path, true);
+      if (result) {
+        console.log(chalk5.green(`Enabled: ${skillName}`));
+        success++;
+      } else {
+        console.log(chalk5.red(`Failed to enable: ${skillName}`));
+        failed++;
+      }
+    }
+    if (success > 0) {
+      console.log(chalk5.dim("\nRun `skillkit sync` to update your agent config"));
+    }
+    return failed > 0 ? 1 : 0;
+  }
+};
+var DisableCommand = class extends Command5 {
+  static paths = [["disable"]];
+  static usage = Command5.Usage({
+    description: "Disable one or more skills",
+    examples: [
+      ["Disable a skill", "$0 disable pdf"],
+      ["Disable multiple skills", "$0 disable pdf xlsx docx"]
+    ]
+  });
+  skills = Option5.Rest({ required: 1 });
+  async execute() {
+    const searchDirs = getSearchDirs();
+    let success = 0;
+    let failed = 0;
+    for (const skillName of this.skills) {
+      const skill = findSkill(skillName, searchDirs);
+      if (!skill) {
+        console.log(chalk5.red(`Skill not found: ${skillName}`));
+        failed++;
+        continue;
+      }
+      if (!skill.enabled) {
+        console.log(chalk5.dim(`Already disabled: ${skillName}`));
+        continue;
+      }
+      const result = setSkillEnabled(skill.path, false);
+      if (result) {
+        console.log(chalk5.yellow(`Disabled: ${skillName}`));
+        success++;
+      } else {
+        console.log(chalk5.red(`Failed to disable: ${skillName}`));
+        failed++;
+      }
+    }
+    if (success > 0) {
+      console.log(chalk5.dim("\nRun `skillkit sync` to update your agent config"));
+    }
+    return failed > 0 ? 1 : 0;
+  }
+};
+
+// src/commands/update.ts
+import { existsSync as existsSync16, rmSync as rmSync5, cpSync as cpSync2 } from "fs";
+import { join as join15 } from "path";
+import chalk6 from "chalk";
+import ora2 from "ora";
+import { Command as Command6, Option as Option6 } from "clipanion";
+init_skills();
+init_providers();
+var UpdateCommand = class extends Command6 {
+  static paths = [["update"], ["u"]];
+  static usage = Command6.Usage({
+    description: "Update skills from their original sources",
+    examples: [
+      ["Update all skills", "$0 update"],
+      ["Update specific skills", "$0 update pdf xlsx"],
+      ["Force update (overwrite local changes)", "$0 update --force"]
+    ]
+  });
+  skills = Option6.Rest();
+  force = Option6.Boolean("--force,-f", false, {
+    description: "Force update even if local changes exist"
+  });
+  async execute() {
+    const spinner = ora2();
+    const searchDirs = getSearchDirs();
+    let skillsToUpdate;
+    if (this.skills.length > 0) {
+      skillsToUpdate = this.skills.map((name) => findSkill(name, searchDirs)).filter((s) => s !== null);
+      const notFound = this.skills.filter((name) => !findSkill(name, searchDirs));
+      if (notFound.length > 0) {
+        console.log(chalk6.yellow(`Skills not found: ${notFound.join(", ")}`));
+      }
+    } else {
+      skillsToUpdate = findAllSkills(searchDirs);
+    }
+    if (skillsToUpdate.length === 0) {
+      console.log(chalk6.yellow("No skills to update"));
+      return 0;
+    }
+    console.log(chalk6.cyan(`Updating ${skillsToUpdate.length} skill(s)...
+`));
+    let updated = 0;
+    let skipped = 0;
+    let failed = 0;
+    for (const skill of skillsToUpdate) {
+      const metadata = loadSkillMetadata(skill.path);
+      if (!metadata) {
+        console.log(chalk6.dim(`Skipping ${skill.name} (no metadata, reinstall needed)`));
+        skipped++;
+        continue;
+      }
+      spinner.start(`Updating ${skill.name}...`);
+      try {
+        if (isLocalPath(metadata.source)) {
+          const localPath = metadata.subpath ? join15(metadata.source, metadata.subpath) : metadata.source;
+          if (!existsSync16(localPath)) {
+            spinner.warn(chalk6.yellow(`${skill.name}: local source missing`));
+            skipped++;
+            continue;
+          }
+          const skillMdPath = join15(localPath, "SKILL.md");
+          if (!existsSync16(skillMdPath)) {
+            spinner.warn(chalk6.yellow(`${skill.name}: no SKILL.md at source`));
+            skipped++;
+            continue;
+          }
+          rmSync5(skill.path, { recursive: true, force: true });
+          cpSync2(localPath, skill.path, { recursive: true, dereference: true });
+          metadata.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+          saveSkillMetadata(skill.path, metadata);
+          spinner.succeed(chalk6.green(`Updated ${skill.name}`));
+          updated++;
+        } else {
+          const provider = detectProvider(metadata.source);
+          if (!provider) {
+            spinner.warn(chalk6.yellow(`${skill.name}: unknown provider`));
+            skipped++;
+            continue;
+          }
+          const result = await provider.clone(metadata.source, "", { depth: 1 });
+          if (!result.success || !result.path) {
+            spinner.fail(chalk6.red(`${skill.name}: ${result.error || "clone failed"}`));
+            failed++;
+            continue;
+          }
+          const sourcePath = metadata.subpath ? join15(result.path, metadata.subpath) : result.path;
+          const skillMdPath = join15(sourcePath, "SKILL.md");
+          if (!existsSync16(skillMdPath)) {
+            spinner.warn(chalk6.yellow(`${skill.name}: no SKILL.md in source`));
+            rmSync5(result.path, { recursive: true, force: true });
+            skipped++;
+            continue;
+          }
+          rmSync5(skill.path, { recursive: true, force: true });
+          cpSync2(sourcePath, skill.path, { recursive: true, dereference: true });
+          rmSync5(result.path, { recursive: true, force: true });
+          metadata.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+          saveSkillMetadata(skill.path, metadata);
+          spinner.succeed(chalk6.green(`Updated ${skill.name}`));
+          updated++;
+        }
+      } catch (error) {
+        spinner.fail(chalk6.red(`Failed to update ${skill.name}`));
+        console.error(chalk6.dim(error instanceof Error ? error.message : String(error)));
+        failed++;
+      }
+    }
+    console.log();
+    console.log(
+      chalk6.cyan(
+        `Updated: ${updated}, Skipped: ${skipped}, Failed: ${failed}`
+      )
+    );
+    return failed > 0 ? 1 : 0;
+  }
+};
+
+// src/commands/remove.ts
+import { existsSync as existsSync17, rmSync as rmSync6 } from "fs";
+import chalk7 from "chalk";
+import { Command as Command7, Option as Option7 } from "clipanion";
+init_skills();
+var RemoveCommand = class extends Command7 {
+  static paths = [["remove"], ["rm"], ["uninstall"]];
+  static usage = Command7.Usage({
+    description: "Remove installed skills",
+    examples: [
+      ["Remove a skill", "$0 remove pdf"],
+      ["Remove multiple skills", "$0 remove pdf xlsx docx"],
+      ["Force removal without confirmation", "$0 remove pdf --force"]
+    ]
+  });
+  skills = Option7.Rest({ required: 1 });
+  force = Option7.Boolean("--force,-f", false, {
+    description: "Skip confirmation"
+  });
+  async execute() {
+    const searchDirs = getSearchDirs();
+    let removed = 0;
+    let failed = 0;
+    for (const skillName of this.skills) {
+      const skill = findSkill(skillName, searchDirs);
+      if (!skill) {
+        console.log(chalk7.yellow(`Skill not found: ${skillName}`));
+        continue;
+      }
+      if (!existsSync17(skill.path)) {
+        console.log(chalk7.yellow(`Path not found: ${skill.path}`));
+        continue;
+      }
+      try {
+        rmSync6(skill.path, { recursive: true, force: true });
+        console.log(chalk7.green(`Removed: ${skillName}`));
+        removed++;
+      } catch (error) {
+        console.log(chalk7.red(`Failed to remove: ${skillName}`));
+        console.error(chalk7.dim(error instanceof Error ? error.message : String(error)));
+        failed++;
+      }
+    }
+    if (removed > 0) {
+      console.log(chalk7.dim("\nRun `skillkit sync` to update your agent config"));
+    }
+    return failed > 0 ? 1 : 0;
+  }
+};
+
+// src/commands/init.ts
+import chalk8 from "chalk";
+import { Command as Command8, Option as Option8 } from "clipanion";
+var InitCommand = class extends Command8 {
+  static paths = [["init"]];
+  static usage = Command8.Usage({
+    description: "Initialize skillkit in a project",
+    examples: [
+      ["Auto-detect agent and initialize", "$0 init"],
+      ["Initialize for specific agent", "$0 init --agent cursor"],
+      ["List supported agents", "$0 init --list"]
+    ]
+  });
+  agent = Option8.String("--agent,-a", {
+    description: "Target agent type"
+  });
+  list = Option8.Boolean("--list,-l", false, {
+    description: "List supported agents"
+  });
+  async execute() {
+    if (this.list) {
+      console.log(chalk8.cyan("Supported agents:\n"));
+      const adapters2 = getAllAdapters();
+      for (const adapter of adapters2) {
+        console.log(`  ${chalk8.green(adapter.type)}`);
+        console.log(`    Name: ${adapter.name}`);
+        console.log(`    Skills dir: ${adapter.skillsDir}`);
+        console.log(`    Config file: ${adapter.configFile}`);
+        console.log();
+      }
+      return 0;
+    }
+    try {
+      let agentType;
+      if (this.agent) {
+        agentType = this.agent;
+      } else {
+        console.log(chalk8.dim("Auto-detecting agent..."));
+        agentType = await detectAgent();
+      }
+      const adapter = getAdapter(agentType);
+      console.log(chalk8.cyan(`Initializing for ${adapter.name}...`));
+      await initProject(agentType);
+      console.log();
+      console.log(chalk8.green("Initialized successfully!"));
+      console.log();
+      console.log(chalk8.dim("Created:"));
+      console.log(chalk8.dim(`  - ${adapter.skillsDir}/ (skills directory)`));
+      console.log(chalk8.dim(`  - skillkit.yaml (config file)`));
+      console.log(chalk8.dim(`  - ${adapter.configFile} (agent config)`));
+      console.log();
+      console.log(chalk8.cyan("Next steps:"));
+      console.log(chalk8.dim("  1. Install skills: skillkit install owner/repo"));
+      console.log(chalk8.dim("  2. Sync config: skillkit sync"));
+      console.log(chalk8.dim("  3. Use skills: skillkit read <skill-name>"));
+      return 0;
+    } catch (error) {
+      console.error(chalk8.red("Initialization failed"));
+      console.error(chalk8.dim(error instanceof Error ? error.message : String(error)));
+      return 1;
+    }
+  }
+};
+
+// src/commands/validate.ts
+init_skills();
+import { existsSync as existsSync18, readdirSync as readdirSync2 } from "fs";
+import { join as join16, basename as basename6 } from "path";
+import chalk9 from "chalk";
+import { Command as Command9, Option as Option9 } from "clipanion";
+var ValidateCommand = class extends Command9 {
+  static paths = [["validate"], ["v"]];
+  static usage = Command9.Usage({
+    description: "Validate skill(s) against the Agent Skills specification (agentskills.io)",
+    examples: [
+      ["Validate a skill directory", "$0 validate ./my-skill"],
+      ["Validate all skills in a directory", "$0 validate ./skills --all"]
+    ]
+  });
+  skillPath = Option9.String({ required: true });
+  all = Option9.Boolean("--all,-a", false, {
+    description: "Validate all skills in the directory"
+  });
+  async execute() {
+    const targetPath = this.skillPath;
+    if (!existsSync18(targetPath)) {
+      console.error(chalk9.red(`Path does not exist: ${targetPath}`));
+      return 1;
+    }
+    const skillPaths = [];
+    if (this.all) {
+      const entries = readdirSync2(targetPath, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.isDirectory()) {
+          const skillPath = join16(targetPath, entry.name);
+          if (existsSync18(join16(skillPath, "SKILL.md"))) {
+            skillPaths.push(skillPath);
+          }
+        }
+      }
+      if (skillPaths.length === 0) {
+        console.error(chalk9.yellow("No skills found in directory"));
+        return 1;
+      }
+    } else {
+      skillPaths.push(targetPath);
+    }
+    let hasErrors = false;
+    for (const skillPath of skillPaths) {
+      const skillName = basename6(skillPath);
+      const result = validateSkill(skillPath);
+      if (result.valid) {
+        console.log(chalk9.green(`\u2713 ${skillName}`));
+        if (result.warnings && result.warnings.length > 0) {
+          result.warnings.forEach((w) => {
+            console.log(chalk9.yellow(`  \u26A0 ${w}`));
+          });
+        }
+      } else {
+        console.log(chalk9.red(`\u2717 ${skillName}`));
+        result.errors.forEach((e) => {
+          console.log(chalk9.red(`  \u2022 ${e}`));
+        });
+        hasErrors = true;
+      }
+    }
+    console.log();
+    if (hasErrors) {
+      console.log(chalk9.red("Validation failed"));
+      console.log(chalk9.dim("See https://agentskills.io/specification for the complete format"));
+      return 1;
+    }
+    console.log(chalk9.green(`Validated ${skillPaths.length} skill(s) successfully`));
+    return 0;
+  }
+};
+
+// src/cli.ts
+var cli = new Cli({
+  binaryLabel: "skillkit",
+  binaryName: "skillkit",
+  binaryVersion: "1.0.0"
+});
+cli.register(Builtins.HelpCommand);
+cli.register(Builtins.VersionCommand);
+cli.register(InstallCommand);
+cli.register(SyncCommand);
+cli.register(ReadCommand);
+cli.register(ListCommand);
+cli.register(EnableCommand);
+cli.register(DisableCommand);
+cli.register(UpdateCommand);
+cli.register(RemoveCommand);
+cli.register(InitCommand);
+cli.register(ValidateCommand);
+cli.runExit(process.argv.slice(2));
+//# sourceMappingURL=cli.js.map