skillkit 1.0.0

package/dist/index.js

@@ -0,0 +1,1276 @@
+// src/core/types.ts
+import { z } from "zod";
+var AgentType = z.enum([
+  "claude-code",
+  "codex",
+  "cursor",
+  "antigravity",
+  "opencode",
+  "gemini-cli",
+  "universal"
+]);
+var GitProvider = z.enum(["github", "gitlab", "bitbucket", "local"]);
+var 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()
+});
+var 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()
+});
+var SkillLocation = z.enum(["project", "global"]);
+var Skill = z.object({
+  name: z.string(),
+  description: z.string(),
+  path: z.string(),
+  location: SkillLocation,
+  metadata: SkillMetadata.optional(),
+  enabled: z.boolean().default(true)
+});
+var 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 extractField(content, field) {
+  const frontmatter = extractFrontmatter(content);
+  if (!frontmatter || !(field in frontmatter)) {
+    return null;
+  }
+  const value = frontmatter[field];
+  return typeof value === "string" ? value : 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("/..");
+}
+
+// src/core/config.ts
+import { existsSync as existsSync9, readFileSync as readFileSync2, writeFileSync, mkdirSync } from "fs";
+import { join as join9, dirname } from "path";
+import { homedir as homedir6 } from "os";
+import { parse as parseYaml2, stringify as stringifyYaml } from "yaml";
+
+// src/agents/claude-code.ts
+import { existsSync as existsSync2 } from "fs";
+import { join as join2 } from "path";
+import { homedir } 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 = join2(process.cwd(), ".claude");
+    const globalClaude = join2(homedir(), ".claude");
+    const claudeMd = join2(process.cwd(), "CLAUDE.md");
+    return existsSync2(projectClaude) || existsSync2(globalClaude) || existsSync2(claudeMd);
+  }
+};
+
+// src/agents/cursor.ts
+import { existsSync as existsSync3 } from "fs";
+import { join as join3 } 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 = join3(process.cwd(), ".cursorrules");
+    const cursorDir = join3(process.cwd(), ".cursor");
+    return existsSync3(cursorRules) || existsSync3(cursorDir);
+  }
+};
+
+// src/agents/codex.ts
+import { existsSync as existsSync4 } from "fs";
+import { join as join4 } from "path";
+import { homedir as homedir2 } 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 = join4(process.cwd(), ".codex");
+    const globalCodex = join4(homedir2(), ".codex");
+    return existsSync4(codexDir) || existsSync4(globalCodex);
+  }
+};
+
+// src/agents/gemini-cli.ts
+import { existsSync as existsSync5 } from "fs";
+import { join as join5 } from "path";
+import { homedir as homedir3 } 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 = join5(process.cwd(), "GEMINI.md");
+    const geminiDir = join5(process.cwd(), ".gemini");
+    const globalGemini = join5(homedir3(), ".gemini");
+    return existsSync5(geminiMd) || existsSync5(geminiDir) || existsSync5(globalGemini);
+  }
+};
+
+// src/agents/opencode.ts
+import { existsSync as existsSync6 } from "fs";
+import { join as join6 } from "path";
+import { homedir as homedir4 } 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 = join6(process.cwd(), ".opencode");
+    const globalOpencode = join6(homedir4(), ".opencode");
+    return existsSync6(opencodeDir) || existsSync6(globalOpencode);
+  }
+};
+
+// src/agents/antigravity.ts
+import { existsSync as existsSync7 } from "fs";
+import { join as join7 } from "path";
+import { homedir as homedir5 } 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 = join7(process.cwd(), ".antigravity");
+    const globalAg = join7(homedir5(), ".antigravity");
+    return existsSync7(agDir) || existsSync7(globalAg);
+  }
+};
+
+// src/agents/universal.ts
+import { existsSync as existsSync8 } from "fs";
+import { join as join8 } 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 = join8(process.cwd(), ".agent");
+    const agentsMd = join8(process.cwd(), "AGENTS.md");
+    return existsSync8(agentDir) || existsSync8(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";
+}
+function getSkillsDir(type) {
+  return adapters[type].skillsDir;
+}
+function getConfigFile(type) {
+  return adapters[type].configFile;
+}
+
+// src/core/config.ts
+var CONFIG_FILE = "skillkit.yaml";
+var METADATA_FILE = ".skillkit.json";
+function getProjectConfigPath() {
+  return join9(process.cwd(), CONFIG_FILE);
+}
+function getGlobalConfigPath() {
+  return join9(homedir6(), ".config", "skillkit", CONFIG_FILE);
+}
+function loadConfig() {
+  const projectPath = getProjectConfigPath();
+  const globalPath = getGlobalConfigPath();
+  if (existsSync9(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 (existsSync9(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 (!existsSync9(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(join9(process.cwd(), adapter.skillsDir));
+  dirs.push(join9(process.cwd(), ".agent", "skills"));
+  dirs.push(join9(homedir6(), adapter.skillsDir));
+  dirs.push(join9(homedir6(), ".agent", "skills"));
+  return dirs;
+}
+function getInstallDir(global = false, agentType) {
+  const type = agentType || loadConfig().agent;
+  const adapter = getAdapter(type);
+  if (global) {
+    return join9(homedir6(), adapter.skillsDir);
+  }
+  return join9(process.cwd(), adapter.skillsDir);
+}
+function getAgentConfigPath(agentType) {
+  const type = agentType || loadConfig().agent;
+  const adapter = getAdapter(type);
+  return join9(process.cwd(), adapter.configFile);
+}
+function saveSkillMetadata(skillPath, metadata) {
+  const metadataPath = join9(skillPath, METADATA_FILE);
+  writeFileSync(metadataPath, JSON.stringify(metadata, null, 2), "utf-8");
+}
+function loadSkillMetadata(skillPath) {
+  const metadataPath = join9(skillPath, METADATA_FILE);
+  if (!existsSync9(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 = join9(process.cwd(), adapter.skillsDir);
+  if (!existsSync9(skillsDir)) {
+    mkdirSync(skillsDir, { recursive: true });
+  }
+  const config = {
+    version: 1,
+    agent: type,
+    autoSync: true
+  };
+  saveConfig(config);
+  const agentConfigPath = join9(process.cwd(), adapter.configFile);
+  if (!existsSync9(agentConfigPath)) {
+    writeFileSync(agentConfigPath, `# ${adapter.name} Configuration
+
+`, "utf-8");
+  }
+}
+
+// src/providers/github.ts
+import { execSync } from "child_process";
+import { existsSync as existsSync10, rmSync } from "fs";
+import { join as join10, basename as basename2 } from "path";
+import { tmpdir } from "os";
+import { randomUUID } from "crypto";
+
+// 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://");
+}
+
+// src/providers/github.ts
+var 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 = join10(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 ? join10(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 (existsSync10(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 existsSync11, rmSync as rmSync2 } from "fs";
+import { join as join11, basename as basename3 } from "path";
+import { tmpdir as tmpdir2 } from "os";
+import { randomUUID as randomUUID2 } from "crypto";
+var 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 = join11(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 ? join11(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 (existsSync11(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 existsSync12, rmSync as rmSync3 } from "fs";
+import { join as join12, basename as basename4 } from "path";
+import { tmpdir as tmpdir3 } from "os";
+import { randomUUID as randomUUID3 } from "crypto";
+var 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 = join12(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 ? join12(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 (existsSync12(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 existsSync13, statSync, realpathSync } from "fs";
+import { join as join13, resolve, basename as basename5 } from "path";
+import { homedir as homedir7 } from "os";
+var LocalProvider = class {
+  type = "local";
+  name = "Local Filesystem";
+  baseUrl = "";
+  parseSource(source) {
+    if (!isLocalPath(source)) {
+      return null;
+    }
+    let expandedPath = source;
+    if (source.startsWith("~/")) {
+      expandedPath = join13(homedir7(), 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 (!existsSync13(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 = [
+  new LocalProvider(),
+  new GitLabProvider(),
+  new BitbucketProvider(),
+  new GitHubProvider()
+];
+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;
+}
+export {
+  AgentType,
+  AntigravityAdapter,
+  BitbucketProvider,
+  ClaudeCodeAdapter,
+  CodexAdapter,
+  CursorAdapter,
+  GeminiCliAdapter,
+  GitHubProvider,
+  GitLabProvider,
+  GitProvider,
+  LocalProvider,
+  OpenCodeAdapter,
+  Skill,
+  SkillFrontmatter,
+  SkillLocation,
+  SkillMetadata,
+  SkillkitConfig,
+  UniversalAdapter,
+  createSkillXml,
+  detectAgent,
+  detectProvider,
+  discoverSkills,
+  escapeXml,
+  extractField,
+  extractFrontmatter,
+  findAllSkills,
+  findSkill,
+  getAdapter,
+  getAgentConfigPath,
+  getAllAdapters,
+  getAllProviders,
+  getConfigFile,
+  getGlobalConfigPath,
+  getInstallDir,
+  getProjectConfigPath,
+  getProvider,
+  getSearchDirs,
+  getSkillsDir,
+  initProject,
+  isGitUrl,
+  isLocalPath,
+  isPathInside,
+  loadConfig,
+  loadMetadata,
+  loadSkillMetadata,
+  parseShorthand,
+  parseSkill,
+  parseSource,
+  readSkillContent,
+  saveConfig,
+  saveSkillMetadata,
+  setSkillEnabled,
+  validateSkill
+};
+//# sourceMappingURL=index.js.map