@skillkit/core 1.3.0

package/dist/index.js

@@ -0,0 +1,3676 @@
+// src/types.ts
+import { z } from "zod";
+var AgentType = z.enum([
+  "claude-code",
+  "codex",
+  "cursor",
+  "antigravity",
+  "opencode",
+  "gemini-cli",
+  "amp",
+  "clawdbot",
+  "droid",
+  "github-copilot",
+  "goose",
+  "kilo",
+  "kiro-cli",
+  "roo",
+  "trae",
+  "windsurf",
+  "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/skills.ts
+import { existsSync, readdirSync, readFileSync } from "fs";
+import { join, basename } from "path";
+import { parse as parseYaml } from "yaml";
+var SKILL_DISCOVERY_PATHS = [
+  "skills",
+  "skills/.curated",
+  "skills/.experimental",
+  "skills/.system",
+  ".agents/skills",
+  ".agent/skills",
+  ".claude/skills",
+  ".codex/skills",
+  ".cursor/skills",
+  ".factory/skills",
+  ".gemini/skills",
+  ".github/skills",
+  ".goose/skills",
+  ".kilocode/skills",
+  ".kiro/skills",
+  ".opencode/skills",
+  ".roo/skills",
+  ".trae/skills",
+  ".windsurf/skills",
+  ".clawdbot/skills",
+  ".antigravity/skills",
+  ".copilot/skills"
+];
+function discoverSkillsInDir(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 discoverSkillsRecursive(dir, seen, maxDepth = 5, currentDepth = 0) {
+  const skills = [];
+  if (currentDepth >= maxDepth || !existsSync(dir)) {
+    return skills;
+  }
+  try {
+    const entries = readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.name === "node_modules" || entry.name === ".git") {
+        continue;
+      }
+      if (!entry.isDirectory()) continue;
+      const entryPath = join(dir, entry.name);
+      const skillMdPath = join(entryPath, "SKILL.md");
+      if (existsSync(skillMdPath)) {
+        const skill = parseSkill(entryPath);
+        if (skill && !seen.has(skill.name)) {
+          seen.add(skill.name);
+          skills.push(skill);
+        }
+      } else {
+        const subSkills = discoverSkillsRecursive(entryPath, seen, maxDepth, currentDepth + 1);
+        skills.push(...subSkills);
+      }
+    }
+  } catch {
+  }
+  return skills;
+}
+function discoverSkills(rootDir) {
+  const skills = [];
+  const seen = /* @__PURE__ */ new Set();
+  const rootSkillMd = join(rootDir, "SKILL.md");
+  if (existsSync(rootSkillMd)) {
+    const skill = parseSkill(rootDir);
+    if (skill && !seen.has(skill.name)) {
+      seen.add(skill.name);
+      skills.push(skill);
+    }
+  }
+  for (const searchPath of SKILL_DISCOVERY_PATHS) {
+    const fullPath = join(rootDir, searchPath);
+    if (existsSync(fullPath)) {
+      for (const skill of discoverSkillsInDir(fullPath)) {
+        if (!seen.has(skill.name)) {
+          seen.add(skill.name);
+          skills.push(skill);
+        }
+      }
+    }
+  }
+  for (const skill of discoverSkillsInDir(rootDir)) {
+    if (!seen.has(skill.name)) {
+      seen.add(skill.name);
+      skills.push(skill);
+    }
+  }
+  if (skills.length === 0) {
+    skills.push(...discoverSkillsRecursive(rootDir, seen));
+  }
+  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/config.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync, mkdirSync } from "fs";
+import { join as join2, dirname } from "path";
+import { homedir } from "os";
+import { parse as parseYaml2, stringify as stringifyYaml } from "yaml";
+var CONFIG_FILE = "skillkit.yaml";
+var METADATA_FILE = ".skillkit.json";
+function getProjectConfigPath() {
+  return join2(process.cwd(), CONFIG_FILE);
+}
+function getGlobalConfigPath() {
+  return join2(homedir(), ".config", "skillkit", CONFIG_FILE);
+}
+function loadConfig() {
+  const projectPath = getProjectConfigPath();
+  const globalPath = getGlobalConfigPath();
+  if (existsSync2(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 (existsSync2(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 (!existsSync2(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  const content = stringifyYaml(config);
+  writeFileSync(configPath, content, "utf-8");
+}
+function getSearchDirs(adapter) {
+  const dirs = [];
+  dirs.push(join2(process.cwd(), adapter.skillsDir));
+  dirs.push(join2(process.cwd(), ".agent", "skills"));
+  dirs.push(join2(homedir(), adapter.skillsDir));
+  dirs.push(join2(homedir(), ".agent", "skills"));
+  return dirs;
+}
+function getInstallDir(adapter, global = false) {
+  if (global) {
+    return join2(homedir(), adapter.skillsDir);
+  }
+  return join2(process.cwd(), adapter.skillsDir);
+}
+function getAgentConfigPath(adapter) {
+  return join2(process.cwd(), adapter.configFile);
+}
+function saveSkillMetadata(skillPath, metadata) {
+  const metadataPath = join2(skillPath, METADATA_FILE);
+  writeFileSync(metadataPath, JSON.stringify(metadata, null, 2), "utf-8");
+}
+function loadSkillMetadata(skillPath) {
+  const metadataPath = join2(skillPath, METADATA_FILE);
+  if (!existsSync2(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(type, adapter) {
+  const skillsDir = join2(process.cwd(), adapter.skillsDir);
+  if (!existsSync2(skillsDir)) {
+    mkdirSync(skillsDir, { recursive: true });
+  }
+  const config = {
+    version: 1,
+    agent: type,
+    autoSync: true
+  };
+  saveConfig(config);
+  const agentConfigPath = join2(process.cwd(), adapter.configFile);
+  if (!existsSync2(agentConfigPath)) {
+    writeFileSync(agentConfigPath, `# ${adapter.name} Configuration
+
+`, "utf-8");
+  }
+}
+
+// src/providers/github.ts
+import { execSync } from "child_process";
+import { existsSync as existsSync3, rmSync } from "fs";
+import { join as join3, 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 = join3(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 ? 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: basename2(s.path),
+          path: s.path
+        }))
+      };
+    } catch (error) {
+      if (existsSync3(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 existsSync4, rmSync as rmSync2 } from "fs";
+import { join as join4, 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 = join4(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 ? 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: basename3(s.path),
+          path: s.path
+        }))
+      };
+    } catch (error) {
+      if (existsSync4(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 existsSync5, rmSync as rmSync3 } from "fs";
+import { join as join5, 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 = join5(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 ? join5(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 (existsSync5(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 existsSync6, statSync, realpathSync } from "fs";
+import { join as join6, resolve, basename as basename5 } from "path";
+import { homedir as homedir2 } 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 = join6(homedir2(), 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 (!existsSync6(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),
+        discoveredSkills: skills.map((s) => ({
+          name: s.name,
+          dirName: basename5(s.path),
+          path: s.path
+        }))
+      };
+    } 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;
+}
+
+// src/translator/types.ts
+import { z as z2 } from "zod";
+var AGENT_FORMAT_MAP = {
+  "claude-code": "skill-md",
+  "codex": "skill-md",
+  "gemini-cli": "skill-md",
+  "opencode": "skill-md",
+  "antigravity": "skill-md",
+  "amp": "skill-md",
+  "clawdbot": "skill-md",
+  "droid": "skill-md",
+  "goose": "skill-md",
+  "kilo": "skill-md",
+  "kiro-cli": "skill-md",
+  "roo": "skill-md",
+  "trae": "skill-md",
+  "universal": "skill-md",
+  "cursor": "cursor-mdc",
+  "windsurf": "markdown-rules",
+  "github-copilot": "markdown-rules"
+};
+var TranslatableSkillFrontmatter = z2.object({
+  name: z2.string(),
+  description: z2.string(),
+  version: z2.string().optional(),
+  author: z2.string().optional(),
+  license: z2.string().optional(),
+  tags: z2.array(z2.string()).optional(),
+  compatibility: z2.string().optional(),
+  "allowed-tools": z2.string().optional(),
+  metadata: z2.record(z2.string()).optional(),
+  // Cursor-specific fields
+  globs: z2.array(z2.string()).optional(),
+  alwaysApply: z2.boolean().optional(),
+  // Agent optimization hints
+  agents: z2.object({
+    optimized: z2.array(z2.string()).optional(),
+    compatible: z2.array(z2.string()).optional()
+  }).optional()
+});
+
+// src/translator/formats/skill-md.ts
+import { parse as parseYaml3, stringify as stringifyYaml2 } from "yaml";
+var SKILL_MD_AGENTS = [
+  "claude-code",
+  "codex",
+  "gemini-cli",
+  "opencode",
+  "antigravity",
+  "amp",
+  "clawdbot",
+  "droid",
+  "goose",
+  "kilo",
+  "kiro-cli",
+  "roo",
+  "trae",
+  "universal"
+];
+function extractFrontmatter2(content) {
+  const match = content.match(/^---\s*\n([\s\S]*?)\n---\s*\n?([\s\S]*)/);
+  if (!match) {
+    return { frontmatter: null, body: content };
+  }
+  try {
+    const frontmatter = parseYaml3(match[1]);
+    return { frontmatter, body: match[2] || "" };
+  } catch {
+    return { frontmatter: null, body: content };
+  }
+}
+var SkillMdTranslator = class {
+  format = "skill-md";
+  agents = SKILL_MD_AGENTS;
+  /**
+   * Parse SKILL.md content into canonical format
+   */
+  parse(content, filename) {
+    const { frontmatter, body } = extractFrontmatter2(content);
+    if (!frontmatter) {
+      const nameMatch = content.match(/^#\s+(.+)$/m);
+      const name2 = nameMatch ? nameMatch[1].toLowerCase().replace(/\s+/g, "-").replace(/[^a-z0-9-]/g, "") : filename?.replace(/\.md$/i, "").replace(/^SKILL$/i, "unnamed-skill") || "unnamed-skill";
+      return {
+        name: name2,
+        description: "Skill without frontmatter",
+        content: body.trim(),
+        sourceFormat: "skill-md"
+      };
+    }
+    const name = frontmatter.name || "unnamed-skill";
+    const description = frontmatter.description || "No description";
+    return {
+      name,
+      description,
+      version: frontmatter.version,
+      author: frontmatter.author,
+      license: frontmatter.license,
+      tags: frontmatter.tags,
+      compatibility: frontmatter.compatibility,
+      allowedTools: frontmatter["allowed-tools"],
+      metadata: frontmatter.metadata,
+      content: body.trim(),
+      sourceFormat: "skill-md",
+      sourceAgent: frontmatter.sourceAgent,
+      globs: frontmatter.globs,
+      alwaysApply: frontmatter.alwaysApply,
+      agentHints: frontmatter.agents
+    };
+  }
+  /**
+   * Check if content is SKILL.md format
+   */
+  detect(content, filename) {
+    if (filename && /SKILL\.md$/i.test(filename)) {
+      return true;
+    }
+    const { frontmatter } = extractFrontmatter2(content);
+    if (frontmatter && ("name" in frontmatter || "description" in frontmatter)) {
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Generate SKILL.md content for target agent
+   */
+  generate(skill, targetAgent, options = {}) {
+    const warnings = [];
+    const incompatible = [];
+    const frontmatter = {
+      name: skill.name,
+      description: skill.description
+    };
+    if (skill.version) frontmatter.version = skill.version;
+    if (skill.author) frontmatter.author = skill.author;
+    if (skill.license) frontmatter.license = skill.license;
+    if (skill.tags?.length) frontmatter.tags = skill.tags;
+    if (skill.compatibility) frontmatter.compatibility = skill.compatibility;
+    if (skill.allowedTools) frontmatter["allowed-tools"] = skill.allowedTools;
+    if (skill.metadata && Object.keys(skill.metadata).length > 0) {
+      frontmatter.metadata = skill.metadata;
+    }
+    if (skill.globs?.length) {
+      frontmatter.globs = skill.globs;
+      warnings.push("Cursor globs preserved but may not be used by target agent");
+    }
+    if (skill.alwaysApply !== void 0) {
+      frontmatter.alwaysApply = skill.alwaysApply;
+      warnings.push("Cursor alwaysApply preserved but may not be used by target agent");
+    }
+    if (options.addMetadata) {
+      frontmatter.translatedFrom = skill.sourceFormat;
+      frontmatter.translatedAt = (/* @__PURE__ */ new Date()).toISOString();
+      frontmatter.targetAgent = targetAgent;
+    }
+    const yamlContent = stringifyYaml2(frontmatter, {
+      lineWidth: 0,
+      defaultKeyType: "PLAIN",
+      defaultStringType: "QUOTE_DOUBLE"
+    }).trim();
+    const content = `---
+${yamlContent}
+---
+
+${skill.content}`;
+    return {
+      success: true,
+      content,
+      filename: this.getFilename(skill.name, targetAgent),
+      warnings,
+      incompatible,
+      targetFormat: "skill-md",
+      targetAgent
+    };
+  }
+  /**
+   * Get the expected filename for SKILL.md format
+   */
+  getFilename(_skillName, _targetAgent) {
+    return "SKILL.md";
+  }
+};
+var skillMdTranslator = new SkillMdTranslator();
+
+// src/translator/formats/cursor.ts
+import { parse as parseYaml4, stringify as stringifyYaml3 } from "yaml";
+function extractFrontmatter3(content) {
+  const match = content.match(/^---\s*\n([\s\S]*?)\n---\s*\n?([\s\S]*)/);
+  if (!match) {
+    return { frontmatter: null, body: content };
+  }
+  try {
+    const frontmatter = parseYaml4(match[1]);
+    return { frontmatter, body: match[2] || "" };
+  } catch {
+    return { frontmatter: null, body: content };
+  }
+}
+function inferGlobs(skill) {
+  const globs = [];
+  const content = skill.content.toLowerCase();
+  const tags = skill.tags || [];
+  const tagExtensions = {
+    "react": ["**/*.tsx", "**/*.jsx"],
+    "typescript": ["**/*.ts", "**/*.tsx"],
+    "javascript": ["**/*.js", "**/*.jsx"],
+    "python": ["**/*.py"],
+    "rust": ["**/*.rs"],
+    "go": ["**/*.go"],
+    "css": ["**/*.css", "**/*.scss", "**/*.sass"],
+    "html": ["**/*.html", "**/*.htm"],
+    "vue": ["**/*.vue"],
+    "svelte": ["**/*.svelte"],
+    "angular": ["**/*.ts", "**/*.html"],
+    "nextjs": ["**/*.tsx", "**/*.ts", "**/*.jsx", "**/*.js"],
+    "testing": ["**/*.test.*", "**/*.spec.*"],
+    "api": ["**/api/**/*", "**/routes/**/*"]
+  };
+  for (const tag of tags) {
+    const normalized = tag.toLowerCase();
+    if (tagExtensions[normalized]) {
+      globs.push(...tagExtensions[normalized]);
+    }
+  }
+  if (content.includes("component") || content.includes("jsx") || content.includes("tsx")) {
+    if (!globs.includes("**/*.tsx")) globs.push("**/*.tsx");
+    if (!globs.includes("**/*.jsx")) globs.push("**/*.jsx");
+  }
+  if (content.includes(".py") || content.includes("python")) {
+    if (!globs.includes("**/*.py")) globs.push("**/*.py");
+  }
+  return [...new Set(globs)];
+}
+var CursorTranslator = class {
+  format = "cursor-mdc";
+  agents = ["cursor"];
+  /**
+   * Parse Cursor MDC content into canonical format
+   */
+  parse(content, filename) {
+    const { frontmatter, body } = extractFrontmatter3(content);
+    let name = "unnamed-skill";
+    if (filename) {
+      name = filename.replace(/\.(mdc|md|cursorrules)$/i, "").replace(/^\./, "").toLowerCase().replace(/\s+/g, "-").replace(/[^a-z0-9-]/g, "");
+    }
+    if (!frontmatter) {
+      return {
+        name,
+        description: "Cursor rules",
+        content: body.trim(),
+        sourceFormat: "cursor-mdc",
+        sourceAgent: "cursor"
+      };
+    }
+    const description = frontmatter.description || "Cursor rule";
+    return {
+      name: frontmatter.name || name,
+      description,
+      content: body.trim(),
+      sourceFormat: "cursor-mdc",
+      sourceAgent: "cursor",
+      globs: frontmatter.globs,
+      alwaysApply: frontmatter.alwaysApply,
+      tags: frontmatter.tags,
+      version: frontmatter.version,
+      author: frontmatter.author
+    };
+  }
+  /**
+   * Check if content is Cursor MDC format
+   */
+  detect(content, filename) {
+    if (filename) {
+      if (/\.mdc$/i.test(filename)) return true;
+      if (/\.cursorrules$/i.test(filename)) return true;
+      if (/cursorrules/i.test(filename)) return true;
+    }
+    const { frontmatter } = extractFrontmatter3(content);
+    if (frontmatter) {
+      if ("globs" in frontmatter || "alwaysApply" in frontmatter) {
+        return true;
+      }
+    }
+    return false;
+  }
+  /**
+   * Generate Cursor MDC content
+   */
+  generate(skill, targetAgent, options = {}) {
+    const warnings = [];
+    const incompatible = [];
+    const frontmatter = {
+      description: skill.description
+    };
+    let globs = options.globs || skill.globs;
+    if (!globs?.length) {
+      globs = inferGlobs(skill);
+      if (globs.length > 0) {
+        warnings.push(`Inferred glob patterns: ${globs.join(", ")}`);
+      }
+    }
+    if (globs?.length) {
+      frontmatter.globs = globs;
+    }
+    const alwaysApply = options.alwaysApply ?? skill.alwaysApply;
+    if (alwaysApply !== void 0) {
+      frontmatter.alwaysApply = alwaysApply;
+    }
+    if (skill.allowedTools) {
+      incompatible.push("allowed-tools: Cursor does not support tool restrictions");
+    }
+    if (skill.compatibility) {
+      warnings.push("compatibility info added as comment");
+    }
+    if (options.addMetadata) {
+      frontmatter.translatedFrom = skill.sourceFormat;
+      frontmatter.originalName = skill.name;
+    }
+    const yamlContent = stringifyYaml3(frontmatter, {
+      lineWidth: 0,
+      defaultKeyType: "PLAIN"
+    }).trim();
+    let body = skill.content;
+    if (skill.compatibility && options.preserveComments !== false) {
+      body = `<!-- Compatibility: ${skill.compatibility} -->
+
+${body}`;
+    }
+    const content = `---
+${yamlContent}
+---
+
+${body}`;
+    return {
+      success: true,
+      content,
+      filename: this.getFilename(skill.name, targetAgent),
+      warnings,
+      incompatible,
+      targetFormat: "cursor-mdc",
+      targetAgent
+    };
+  }
+  /**
+   * Generate .cursorrules content (alternative format)
+   */
+  generateCursorrules(skill) {
+    let content = "";
+    content += `# ${skill.name}
+`;
+    content += `# ${skill.description}
+
+`;
+    content += skill.content;
+    return content;
+  }
+  /**
+   * Get the expected filename for Cursor format
+   */
+  getFilename(skillName, _targetAgent) {
+    const safeName = skillName.toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+    return `${safeName}.mdc`;
+  }
+};
+var cursorTranslator = new CursorTranslator();
+
+// src/translator/formats/windsurf.ts
+function parseMetadataComments(content) {
+  const metadata = {};
+  const lines = content.split("\n");
+  const bodyLines = [];
+  let inMetadata = true;
+  for (const line of lines) {
+    if (inMetadata) {
+      const match = line.match(/^<!--\s*(\w+):\s*(.+?)\s*-->$/);
+      if (match) {
+        metadata[match[1].toLowerCase()] = match[2];
+        continue;
+      }
+      if (line.trim() && !line.startsWith("<!--")) {
+        inMetadata = false;
+      }
+    }
+    bodyLines.push(line);
+  }
+  return {
+    metadata,
+    body: bodyLines.join("\n").trim()
+  };
+}
+var WindsurfTranslator = class {
+  format = "markdown-rules";
+  agents = ["windsurf"];
+  /**
+   * Parse Windsurf rules content into canonical format
+   */
+  parse(content, filename) {
+    const { metadata, body } = parseMetadataComments(content);
+    let name = metadata.name;
+    if (!name) {
+      const headingMatch = body.match(/^#\s+(.+)$/m);
+      if (headingMatch) {
+        name = headingMatch[1].toLowerCase().replace(/\s+/g, "-").replace(/[^a-z0-9-]/g, "");
+      } else if (filename) {
+        name = filename.replace(/\.(windsurfrules|md)$/i, "").replace(/^\./, "").toLowerCase().replace(/\s+/g, "-").replace(/[^a-z0-9-]/g, "");
+      } else {
+        name = "unnamed-skill";
+      }
+    }
+    let description = metadata.description;
+    if (!description) {
+      const paragraphMatch = body.match(/^(?!#)[^\n]+/m);
+      if (paragraphMatch) {
+        description = paragraphMatch[0].substring(0, 200);
+        if (description.length === 200) description += "...";
+      } else {
+        description = "Windsurf rules";
+      }
+    }
+    return {
+      name,
+      description,
+      content: body,
+      sourceFormat: "markdown-rules",
+      sourceAgent: "windsurf",
+      version: metadata.version,
+      author: metadata.author,
+      tags: metadata.tags?.split(",").map((t) => t.trim())
+    };
+  }
+  /**
+   * Check if content is Windsurf format
+   */
+  detect(content, filename) {
+    if (filename) {
+      if (/\.windsurfrules$/i.test(filename)) return true;
+      if (/windsurfrules/i.test(filename)) return true;
+    }
+    if (content.startsWith("<!--") && content.includes("-->")) {
+      const { metadata } = parseMetadataComments(content);
+      if (Object.keys(metadata).length > 0) {
+        return true;
+      }
+    }
+    return false;
+  }
+  /**
+   * Generate Windsurf rules content
+   */
+  generate(skill, targetAgent, options = {}) {
+    const warnings = [];
+    const incompatible = [];
+    const lines = [];
+    if (options.addMetadata !== false) {
+      lines.push(`<!-- name: ${skill.name} -->`);
+      lines.push(`<!-- description: ${skill.description} -->`);
+      if (skill.version) lines.push(`<!-- version: ${skill.version} -->`);
+      if (skill.author) lines.push(`<!-- author: ${skill.author} -->`);
+      if (skill.tags?.length) lines.push(`<!-- tags: ${skill.tags.join(", ")} -->`);
+      if (options.addMetadata) {
+        lines.push(`<!-- translatedFrom: ${skill.sourceFormat} -->`);
+        lines.push(`<!-- translatedAt: ${(/* @__PURE__ */ new Date()).toISOString()} -->`);
+      }
+      lines.push("");
+    }
+    if (skill.globs?.length) {
+      incompatible.push("globs: Windsurf does not support file pattern matching");
+    }
+    if (skill.alwaysApply !== void 0) {
+      incompatible.push("alwaysApply: Windsurf does not support conditional application");
+    }
+    if (skill.allowedTools) {
+      incompatible.push("allowed-tools: Windsurf does not support tool restrictions");
+    }
+    lines.push(skill.content);
+    return {
+      success: true,
+      content: lines.join("\n"),
+      filename: this.getFilename(skill.name, targetAgent),
+      warnings,
+      incompatible,
+      targetFormat: "markdown-rules",
+      targetAgent
+    };
+  }
+  /**
+   * Get the expected filename for Windsurf format
+   */
+  getFilename(_skillName, _targetAgent) {
+    return ".windsurfrules";
+  }
+};
+var windsurfTranslator = new WindsurfTranslator();
+
+// src/translator/formats/copilot.ts
+function parseMetadataComments2(content) {
+  const metadata = {};
+  const lines = content.split("\n");
+  const bodyLines = [];
+  let inMetadata = true;
+  for (const line of lines) {
+    if (inMetadata) {
+      const match = line.match(/^<!--\s*(\w+):\s*(.+?)\s*-->$/);
+      if (match) {
+        metadata[match[1].toLowerCase()] = match[2];
+        continue;
+      }
+      if (line.trim() && !line.startsWith("<!--")) {
+        inMetadata = false;
+      }
+    }
+    bodyLines.push(line);
+  }
+  return {
+    metadata,
+    body: bodyLines.join("\n").trim()
+  };
+}
+var CopilotTranslator = class {
+  format = "markdown-rules";
+  agents = ["github-copilot"];
+  /**
+   * Parse Copilot instructions into canonical format
+   */
+  parse(content, filename) {
+    const { metadata, body } = parseMetadataComments2(content);
+    let name = metadata.name;
+    if (!name) {
+      const headingMatch = body.match(/^#\s+(.+)$/m);
+      if (headingMatch) {
+        name = headingMatch[1].toLowerCase().replace(/\s+/g, "-").replace(/[^a-z0-9-]/g, "");
+      } else if (filename) {
+        name = filename.replace(/\.(md)$/i, "").replace(/copilot-instructions/i, "copilot-rules").toLowerCase().replace(/\s+/g, "-").replace(/[^a-z0-9-]/g, "");
+      } else {
+        name = "copilot-instructions";
+      }
+    }
+    let description = metadata.description;
+    if (!description) {
+      const paragraphMatch = body.match(/^(?!#)[^\n]+/m);
+      if (paragraphMatch) {
+        description = paragraphMatch[0].substring(0, 200);
+        if (description.length === 200) description += "...";
+      } else {
+        description = "GitHub Copilot instructions";
+      }
+    }
+    return {
+      name,
+      description,
+      content: body,
+      sourceFormat: "markdown-rules",
+      sourceAgent: "github-copilot",
+      version: metadata.version,
+      author: metadata.author,
+      tags: metadata.tags?.split(",").map((t) => t.trim())
+    };
+  }
+  /**
+   * Check if content is GitHub Copilot format
+   */
+  detect(content, filename) {
+    if (filename) {
+      if (/copilot-instructions\.md$/i.test(filename)) return true;
+      if (/copilot.*instructions/i.test(filename)) return true;
+    }
+    if (content.toLowerCase().includes("github copilot")) {
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Generate GitHub Copilot instructions content
+   */
+  generate(skill, targetAgent, options = {}) {
+    const warnings = [];
+    const incompatible = [];
+    const lines = [];
+    lines.push("<!-- This file provides custom instructions for GitHub Copilot -->");
+    lines.push("<!-- Generated by SkillKit - https://github.com/rohitg00/skillkit -->");
+    lines.push("");
+    if (options.addMetadata) {
+      lines.push(`<!-- name: ${skill.name} -->`);
+      lines.push(`<!-- description: ${skill.description} -->`);
+      if (skill.version) lines.push(`<!-- version: ${skill.version} -->`);
+      if (skill.author) lines.push(`<!-- author: ${skill.author} -->`);
+      lines.push(`<!-- translatedFrom: ${skill.sourceFormat} -->`);
+      lines.push(`<!-- translatedAt: ${(/* @__PURE__ */ new Date()).toISOString()} -->`);
+      lines.push("");
+    }
+    if (skill.globs?.length) {
+      incompatible.push("globs: GitHub Copilot does not support file pattern matching");
+    }
+    if (skill.alwaysApply !== void 0) {
+      incompatible.push("alwaysApply: GitHub Copilot does not support conditional application");
+    }
+    if (skill.allowedTools) {
+      incompatible.push("allowed-tools: GitHub Copilot does not support tool restrictions");
+    }
+    if (skill.metadata && Object.keys(skill.metadata).length > 0) {
+      warnings.push("Custom metadata fields not supported by GitHub Copilot");
+    }
+    if (!skill.content.trim().startsWith("#")) {
+      lines.push(`# ${skill.name.split("-").map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ")}`);
+      lines.push("");
+      if (skill.description) {
+        lines.push(skill.description);
+        lines.push("");
+      }
+    }
+    lines.push(skill.content);
+    return {
+      success: true,
+      content: lines.join("\n"),
+      filename: this.getFilename(skill.name, targetAgent),
+      warnings,
+      incompatible,
+      targetFormat: "markdown-rules",
+      targetAgent
+    };
+  }
+  /**
+   * Get the expected filename for GitHub Copilot format
+   */
+  getFilename(_skillName, _targetAgent) {
+    return "copilot-instructions.md";
+  }
+  /**
+   * Get the expected path for the instructions file
+   */
+  getPath(_skillName) {
+    return ".github/copilot-instructions.md";
+  }
+};
+var copilotTranslator = new CopilotTranslator();
+
+// src/translator/registry.ts
+import { existsSync as existsSync7, readFileSync as readFileSync3, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2 } from "fs";
+import { dirname as dirname2, basename as basename6 } from "path";
+var TranslatorRegistry = class {
+  translators = /* @__PURE__ */ new Map();
+  agentTranslators = /* @__PURE__ */ new Map();
+  constructor() {
+    this.register(skillMdTranslator);
+    this.register(cursorTranslator);
+    this.register(windsurfTranslator);
+    this.register(copilotTranslator);
+  }
+  /**
+   * Register a format translator
+   */
+  register(translator) {
+    this.translators.set(translator.format, translator);
+    for (const agent of translator.agents) {
+      this.agentTranslators.set(agent, translator);
+    }
+  }
+  /**
+   * Get translator for a specific format
+   */
+  getTranslator(format) {
+    return this.translators.get(format);
+  }
+  /**
+   * Get translator for a specific agent
+   */
+  getTranslatorForAgent(agent) {
+    const specific = this.agentTranslators.get(agent);
+    if (specific) {
+      return specific;
+    }
+    return skillMdTranslator;
+  }
+  /**
+   * Get the format category for an agent
+   */
+  getFormatForAgent(agent) {
+    return AGENT_FORMAT_MAP[agent] || "skill-md";
+  }
+  /**
+   * Detect the format of content
+   */
+  detectFormat(content, filename) {
+    for (const [format, translator] of this.translators) {
+      if (translator.detect(content, filename)) {
+        return format;
+      }
+    }
+    if (content.startsWith("---")) {
+      return "skill-md";
+    }
+    return null;
+  }
+  /**
+   * Detect the source agent from content
+   */
+  detectSourceAgent(content, filename) {
+    const format = this.detectFormat(content, filename);
+    if (!format) return null;
+    if (filename) {
+      const lower = filename.toLowerCase();
+      if (lower.includes("cursor") || lower.endsWith(".mdc")) return "cursor";
+      if (lower.includes("windsurf")) return "windsurf";
+      if (lower.includes("copilot")) return "github-copilot";
+    }
+    for (const [agent, agentFormat] of Object.entries(AGENT_FORMAT_MAP)) {
+      if (agentFormat === format) {
+        return agent;
+      }
+    }
+    return null;
+  }
+  /**
+   * Parse content into canonical format
+   */
+  parse(content, filename) {
+    const format = this.detectFormat(content, filename);
+    if (!format) {
+      return skillMdTranslator.parse(content, filename);
+    }
+    const translator = this.translators.get(format);
+    if (!translator) {
+      return null;
+    }
+    return translator.parse(content, filename);
+  }
+  /**
+   * Translate skill to target agent format
+   */
+  translate(skill, targetAgent, options = {}) {
+    const translator = this.getTranslatorForAgent(targetAgent);
+    return translator.generate(skill, targetAgent, options);
+  }
+  /**
+   * Translate content directly from one agent to another
+   */
+  translateContent(content, targetAgent, options = {}) {
+    const skill = this.parse(content, options.sourceFilename);
+    if (!skill) {
+      return {
+        success: false,
+        content: "",
+        filename: "",
+        warnings: [],
+        incompatible: ["Failed to parse source content"],
+        targetFormat: this.getFormatForAgent(targetAgent),
+        targetAgent
+      };
+    }
+    return this.translate(skill, targetAgent, options);
+  }
+  /**
+   * Translate a skill file to target agent format
+   */
+  translateFile(sourcePath, targetAgent, options = {}) {
+    if (!existsSync7(sourcePath)) {
+      return {
+        success: false,
+        content: "",
+        filename: "",
+        warnings: [],
+        incompatible: [`Source file not found: ${sourcePath}`],
+        targetFormat: this.getFormatForAgent(targetAgent),
+        targetAgent
+      };
+    }
+    const content = readFileSync3(sourcePath, "utf-8");
+    const filename = basename6(sourcePath);
+    return this.translateContent(content, targetAgent, {
+      ...options,
+      sourceFilename: filename
+    });
+  }
+  /**
+   * Translate and write to target path
+   */
+  translateAndWrite(sourcePath, targetPath, targetAgent, options = {}) {
+    const result = this.translateFile(sourcePath, targetAgent, options);
+    if (result.success) {
+      const targetDir = dirname2(targetPath);
+      if (!existsSync7(targetDir)) {
+        mkdirSync2(targetDir, { recursive: true });
+      }
+      writeFileSync2(targetPath, result.content, "utf-8");
+    }
+    return result;
+  }
+  /**
+   * Get all supported agents
+   */
+  getSupportedAgents() {
+    return Object.keys(AGENT_FORMAT_MAP);
+  }
+  /**
+   * Get all registered formats
+   */
+  getRegisteredFormats() {
+    return Array.from(this.translators.keys());
+  }
+  /**
+   * Check if translation is supported between two agents
+   */
+  canTranslate(from, to) {
+    return this.getSupportedAgents().includes(from) && this.getSupportedAgents().includes(to);
+  }
+  /**
+   * Get translation compatibility info
+   */
+  getCompatibilityInfo(from, to) {
+    const fromFormat = this.getFormatForAgent(from);
+    const toFormat = this.getFormatForAgent(to);
+    const warnings = [];
+    const lossyFields = [];
+    if (fromFormat === "cursor-mdc" && toFormat !== "cursor-mdc") {
+      lossyFields.push("globs", "alwaysApply");
+      warnings.push("Cursor-specific features (globs, alwaysApply) will be preserved but not used");
+    }
+    if (fromFormat === "skill-md" && toFormat === "markdown-rules") {
+      lossyFields.push("allowed-tools", "metadata");
+      warnings.push("Advanced SKILL.md features will be stored as comments");
+    }
+    return {
+      supported: this.canTranslate(from, to),
+      warnings,
+      lossyFields
+    };
+  }
+};
+var translatorRegistry = new TranslatorRegistry();
+
+// src/translator/index.ts
+function translateSkill(content, targetAgent, options) {
+  return translatorRegistry.translateContent(content, targetAgent, options);
+}
+function translateSkillFile(sourcePath, targetAgent, options) {
+  return translatorRegistry.translateFile(sourcePath, targetAgent, options);
+}
+function parseSkillContent(content, filename) {
+  return translatorRegistry.parse(content, filename);
+}
+function detectSkillFormat(content, filename) {
+  return translatorRegistry.detectFormat(content, filename);
+}
+function getSupportedTranslationAgents() {
+  return translatorRegistry.getSupportedAgents();
+}
+function canTranslate(from, to) {
+  return translatorRegistry.canTranslate(from, to);
+}
+
+// src/context/types.ts
+import { z as z3 } from "zod";
+var DependencyInfo = z3.object({
+  name: z3.string(),
+  version: z3.string().optional(),
+  dev: z3.boolean().default(false)
+});
+var Detection = z3.object({
+  name: z3.string(),
+  version: z3.string().optional(),
+  confidence: z3.number().min(0).max(100).default(100),
+  source: z3.string().optional()
+  // Where it was detected from
+});
+var ProjectStack = z3.object({
+  languages: z3.array(Detection).default([]),
+  frameworks: z3.array(Detection).default([]),
+  libraries: z3.array(Detection).default([]),
+  styling: z3.array(Detection).default([]),
+  testing: z3.array(Detection).default([]),
+  databases: z3.array(Detection).default([]),
+  tools: z3.array(Detection).default([]),
+  runtime: z3.array(Detection).default([])
+});
+var ProjectPatterns = z3.object({
+  components: z3.string().optional(),
+  // 'functional', 'class', 'mixed'
+  stateManagement: z3.string().optional(),
+  // 'redux', 'zustand', 'context', etc.
+  apiStyle: z3.string().optional(),
+  // 'rest', 'graphql', 'trpc', 'server-actions'
+  styling: z3.string().optional(),
+  // 'css-modules', 'tailwind', 'styled-components'
+  testing: z3.string().optional(),
+  // 'jest', 'vitest', 'playwright'
+  linting: z3.string().optional(),
+  // 'eslint', 'biome'
+  formatting: z3.string().optional()
+  // 'prettier', 'biome'
+});
+var SkillPreferences = z3.object({
+  installed: z3.array(z3.string()).default([]),
+  recommended: z3.array(z3.string()).default([]),
+  excluded: z3.array(z3.string()).default([]),
+  autoSync: z3.boolean().default(true),
+  securityLevel: z3.enum(["low", "medium", "high"]).default("medium"),
+  testingRequired: z3.boolean().default(false)
+});
+var AgentConfig = z3.object({
+  primary: z3.string().optional(),
+  // Primary agent
+  detected: z3.array(z3.string()).default([]),
+  // Auto-detected agents
+  synced: z3.array(z3.string()).default([]),
+  // Agents to sync skills to
+  disabled: z3.array(z3.string()).default([])
+  // Agents to skip
+});
+var ProjectContext = z3.object({
+  version: z3.literal(1),
+  project: z3.object({
+    name: z3.string(),
+    description: z3.string().optional(),
+    type: z3.string().optional(),
+    // 'web-app', 'cli', 'library', 'api', etc.
+    path: z3.string().optional()
+  }),
+  stack: ProjectStack,
+  patterns: ProjectPatterns.optional(),
+  skills: SkillPreferences.optional(),
+  agents: AgentConfig.optional(),
+  createdAt: z3.string().datetime().optional(),
+  updatedAt: z3.string().datetime().optional()
+});
+var CONTEXT_FILE = ".skillkit/context.yaml";
+var CONTEXT_DIR = ".skillkit";
+var PROJECT_TYPE_HINTS = {
+  "web-app": ["react", "vue", "angular", "svelte", "nextjs", "nuxt", "remix"],
+  "api": ["express", "fastify", "koa", "hono", "fastapi", "flask", "django"],
+  "cli": ["commander", "yargs", "clipanion", "clap", "cobra"],
+  "library": ["rollup", "esbuild", "tsup", "unbuild"],
+  "mobile": ["react-native", "expo", "flutter", "ionic"],
+  "desktop": ["electron", "tauri"]
+};
+
+// src/context/detector.ts
+import { existsSync as existsSync8, readFileSync as readFileSync4, readdirSync as readdirSync2 } from "fs";
+import { join as join7, basename as basename7 } from "path";
+var FRAMEWORK_PATTERNS = {
+  // Frontend frameworks
+  react: {
+    dependencies: ["react", "react-dom"],
+    files: [],
+    category: "frameworks",
+    tags: ["react", "frontend", "ui"]
+  },
+  nextjs: {
+    dependencies: ["next"],
+    files: ["next.config.js", "next.config.mjs", "next.config.ts"],
+    category: "frameworks",
+    tags: ["nextjs", "react", "ssr", "frontend"]
+  },
+  vue: {
+    dependencies: ["vue"],
+    files: [],
+    category: "frameworks",
+    tags: ["vue", "frontend", "ui"]
+  },
+  nuxt: {
+    dependencies: ["nuxt"],
+    files: ["nuxt.config.js", "nuxt.config.ts"],
+    category: "frameworks",
+    tags: ["nuxt", "vue", "ssr", "frontend"]
+  },
+  angular: {
+    dependencies: ["@angular/core"],
+    files: ["angular.json"],
+    category: "frameworks",
+    tags: ["angular", "frontend", "ui"]
+  },
+  svelte: {
+    dependencies: ["svelte"],
+    files: ["svelte.config.js"],
+    category: "frameworks",
+    tags: ["svelte", "frontend", "ui"]
+  },
+  remix: {
+    dependencies: ["@remix-run/react"],
+    files: ["remix.config.js"],
+    category: "frameworks",
+    tags: ["remix", "react", "ssr", "frontend"]
+  },
+  astro: {
+    dependencies: ["astro"],
+    files: ["astro.config.mjs", "astro.config.ts"],
+    category: "frameworks",
+    tags: ["astro", "static", "frontend"]
+  },
+  solid: {
+    dependencies: ["solid-js"],
+    files: [],
+    category: "frameworks",
+    tags: ["solid", "frontend", "ui"]
+  },
+  // Backend frameworks
+  express: {
+    dependencies: ["express"],
+    files: [],
+    category: "frameworks",
+    tags: ["express", "nodejs", "api", "backend"]
+  },
+  fastify: {
+    dependencies: ["fastify"],
+    files: [],
+    category: "frameworks",
+    tags: ["fastify", "nodejs", "api", "backend"]
+  },
+  hono: {
+    dependencies: ["hono"],
+    files: [],
+    category: "frameworks",
+    tags: ["hono", "edge", "api", "backend"]
+  },
+  koa: {
+    dependencies: ["koa"],
+    files: [],
+    category: "frameworks",
+    tags: ["koa", "nodejs", "api", "backend"]
+  },
+  nestjs: {
+    dependencies: ["@nestjs/core"],
+    files: ["nest-cli.json"],
+    category: "frameworks",
+    tags: ["nestjs", "nodejs", "api", "backend"]
+  },
+  // Mobile
+  "react-native": {
+    dependencies: ["react-native"],
+    files: ["metro.config.js", "app.json"],
+    category: "frameworks",
+    tags: ["react-native", "mobile", "ios", "android"]
+  },
+  expo: {
+    dependencies: ["expo"],
+    files: ["app.json", "expo.json"],
+    category: "frameworks",
+    tags: ["expo", "react-native", "mobile"]
+  },
+  // Desktop
+  electron: {
+    dependencies: ["electron"],
+    files: ["electron.js", "electron-builder.json"],
+    category: "frameworks",
+    tags: ["electron", "desktop"]
+  },
+  tauri: {
+    dependencies: ["@tauri-apps/api"],
+    files: ["tauri.conf.json", "src-tauri"],
+    category: "frameworks",
+    tags: ["tauri", "desktop", "rust"]
+  }
+};
+var LIBRARY_PATTERNS = {
+  // State management
+  redux: {
+    dependencies: ["redux", "@reduxjs/toolkit"],
+    category: "libraries",
+    tags: ["redux", "state-management"]
+  },
+  zustand: {
+    dependencies: ["zustand"],
+    category: "libraries",
+    tags: ["zustand", "state-management"]
+  },
+  jotai: {
+    dependencies: ["jotai"],
+    category: "libraries",
+    tags: ["jotai", "state-management"]
+  },
+  recoil: {
+    dependencies: ["recoil"],
+    category: "libraries",
+    tags: ["recoil", "state-management"]
+  },
+  mobx: {
+    dependencies: ["mobx"],
+    category: "libraries",
+    tags: ["mobx", "state-management"]
+  },
+  // Data fetching
+  tanstack: {
+    dependencies: ["@tanstack/react-query", "@tanstack/query-core"],
+    category: "libraries",
+    tags: ["tanstack", "data-fetching", "caching"]
+  },
+  swr: {
+    dependencies: ["swr"],
+    category: "libraries",
+    tags: ["swr", "data-fetching"]
+  },
+  trpc: {
+    dependencies: ["@trpc/client", "@trpc/server"],
+    category: "libraries",
+    tags: ["trpc", "api", "typescript"]
+  },
+  graphql: {
+    dependencies: ["graphql", "@apollo/client", "urql"],
+    category: "libraries",
+    tags: ["graphql", "api"]
+  },
+  // UI Components
+  "shadcn-ui": {
+    dependencies: ["@radix-ui/react-slot"],
+    files: ["components.json"],
+    category: "libraries",
+    tags: ["shadcn", "ui", "components"]
+  },
+  "material-ui": {
+    dependencies: ["@mui/material"],
+    category: "libraries",
+    tags: ["mui", "material", "ui", "components"]
+  },
+  "chakra-ui": {
+    dependencies: ["@chakra-ui/react"],
+    category: "libraries",
+    tags: ["chakra", "ui", "components"]
+  },
+  "ant-design": {
+    dependencies: ["antd"],
+    category: "libraries",
+    tags: ["antd", "ui", "components"]
+  },
+  // Form handling
+  "react-hook-form": {
+    dependencies: ["react-hook-form"],
+    category: "libraries",
+    tags: ["forms", "validation"]
+  },
+  formik: {
+    dependencies: ["formik"],
+    category: "libraries",
+    tags: ["forms", "validation"]
+  },
+  zod: {
+    dependencies: ["zod"],
+    category: "libraries",
+    tags: ["validation", "schema", "typescript"]
+  },
+  // Animation
+  "framer-motion": {
+    dependencies: ["framer-motion"],
+    category: "libraries",
+    tags: ["animation", "motion"]
+  }
+};
+var STYLING_PATTERNS = {
+  tailwindcss: {
+    dependencies: ["tailwindcss"],
+    files: ["tailwind.config.js", "tailwind.config.ts", "tailwind.config.cjs"],
+    category: "styling",
+    tags: ["tailwind", "css", "utility-first"]
+  },
+  "styled-components": {
+    dependencies: ["styled-components"],
+    category: "styling",
+    tags: ["styled-components", "css-in-js"]
+  },
+  emotion: {
+    dependencies: ["@emotion/react", "@emotion/styled"],
+    category: "styling",
+    tags: ["emotion", "css-in-js"]
+  },
+  sass: {
+    dependencies: ["sass", "node-sass"],
+    category: "styling",
+    tags: ["sass", "scss", "css"]
+  },
+  less: {
+    dependencies: ["less"],
+    category: "styling",
+    tags: ["less", "css"]
+  },
+  "css-modules": {
+    files: ["*.module.css", "*.module.scss"],
+    category: "styling",
+    tags: ["css-modules", "css"]
+  }
+};
+var TESTING_PATTERNS = {
+  jest: {
+    dependencies: ["jest"],
+    files: ["jest.config.js", "jest.config.ts"],
+    category: "testing",
+    tags: ["jest", "testing", "unit-testing"]
+  },
+  vitest: {
+    dependencies: ["vitest"],
+    files: ["vitest.config.ts", "vitest.config.js"],
+    category: "testing",
+    tags: ["vitest", "testing", "unit-testing"]
+  },
+  playwright: {
+    dependencies: ["@playwright/test"],
+    files: ["playwright.config.ts", "playwright.config.js"],
+    category: "testing",
+    tags: ["playwright", "e2e", "testing"]
+  },
+  cypress: {
+    dependencies: ["cypress"],
+    files: ["cypress.config.ts", "cypress.config.js", "cypress.json"],
+    category: "testing",
+    tags: ["cypress", "e2e", "testing"]
+  },
+  mocha: {
+    dependencies: ["mocha"],
+    category: "testing",
+    tags: ["mocha", "testing"]
+  },
+  "testing-library": {
+    dependencies: ["@testing-library/react", "@testing-library/vue"],
+    category: "testing",
+    tags: ["testing-library", "testing"]
+  }
+};
+var DATABASE_PATTERNS = {
+  prisma: {
+    dependencies: ["@prisma/client", "prisma"],
+    files: ["prisma/schema.prisma"],
+    category: "databases",
+    tags: ["prisma", "orm", "database"]
+  },
+  drizzle: {
+    dependencies: ["drizzle-orm"],
+    files: ["drizzle.config.ts"],
+    category: "databases",
+    tags: ["drizzle", "orm", "database"]
+  },
+  typeorm: {
+    dependencies: ["typeorm"],
+    category: "databases",
+    tags: ["typeorm", "orm", "database"]
+  },
+  mongoose: {
+    dependencies: ["mongoose"],
+    category: "databases",
+    tags: ["mongoose", "mongodb", "database"]
+  },
+  supabase: {
+    dependencies: ["@supabase/supabase-js"],
+    category: "databases",
+    tags: ["supabase", "postgres", "database", "auth"]
+  },
+  firebase: {
+    dependencies: ["firebase", "firebase-admin"],
+    category: "databases",
+    tags: ["firebase", "database", "auth"]
+  }
+};
+var TOOL_PATTERNS = {
+  eslint: {
+    dependencies: ["eslint"],
+    files: [".eslintrc", ".eslintrc.js", ".eslintrc.json", "eslint.config.js"],
+    category: "tools",
+    tags: ["eslint", "linting"]
+  },
+  prettier: {
+    dependencies: ["prettier"],
+    files: [".prettierrc", ".prettierrc.js", "prettier.config.js"],
+    category: "tools",
+    tags: ["prettier", "formatting"]
+  },
+  biome: {
+    dependencies: ["@biomejs/biome"],
+    files: ["biome.json"],
+    category: "tools",
+    tags: ["biome", "linting", "formatting"]
+  },
+  husky: {
+    dependencies: ["husky"],
+    files: [".husky"],
+    category: "tools",
+    tags: ["husky", "git-hooks"]
+  },
+  "lint-staged": {
+    dependencies: ["lint-staged"],
+    category: "tools",
+    tags: ["lint-staged", "git-hooks"]
+  },
+  turbo: {
+    dependencies: ["turbo"],
+    files: ["turbo.json"],
+    category: "tools",
+    tags: ["turbo", "monorepo", "build"]
+  },
+  nx: {
+    dependencies: ["nx"],
+    files: ["nx.json"],
+    category: "tools",
+    tags: ["nx", "monorepo", "build"]
+  },
+  docker: {
+    files: ["Dockerfile", "docker-compose.yml", "docker-compose.yaml"],
+    category: "tools",
+    tags: ["docker", "containers"]
+  }
+};
+var ProjectDetector = class {
+  projectPath;
+  packageJson = null;
+  files = /* @__PURE__ */ new Set();
+  constructor(projectPath) {
+    this.projectPath = projectPath;
+  }
+  /**
+   * Analyze the project and return detected stack
+   */
+  analyze() {
+    this.loadPackageJson();
+    this.scanFiles();
+    const stack = {
+      languages: this.detectLanguages(),
+      frameworks: this.detectFromPatterns(FRAMEWORK_PATTERNS),
+      libraries: this.detectFromPatterns(LIBRARY_PATTERNS),
+      styling: this.detectFromPatterns(STYLING_PATTERNS),
+      testing: this.detectFromPatterns(TESTING_PATTERNS),
+      databases: this.detectFromPatterns(DATABASE_PATTERNS),
+      tools: this.detectFromPatterns(TOOL_PATTERNS),
+      runtime: this.detectRuntime()
+    };
+    return stack;
+  }
+  /**
+   * Detect project patterns and conventions
+   */
+  detectPatterns() {
+    const patterns = {};
+    if (this.hasFile("*.tsx") || this.hasFile("*.jsx")) {
+      patterns.components = "functional";
+    }
+    const deps = this.getDependencies();
+    if (deps.has("zustand")) patterns.stateManagement = "zustand";
+    else if (deps.has("@reduxjs/toolkit") || deps.has("redux")) patterns.stateManagement = "redux";
+    else if (deps.has("jotai")) patterns.stateManagement = "jotai";
+    else if (deps.has("recoil")) patterns.stateManagement = "recoil";
+    else if (deps.has("mobx")) patterns.stateManagement = "mobx";
+    if (deps.has("@trpc/client")) patterns.apiStyle = "trpc";
+    else if (deps.has("graphql") || deps.has("@apollo/client")) patterns.apiStyle = "graphql";
+    else if (deps.has("next") && this.hasFile("app/**/actions.ts")) patterns.apiStyle = "server-actions";
+    else patterns.apiStyle = "rest";
+    if (deps.has("tailwindcss")) patterns.styling = "tailwind";
+    else if (deps.has("styled-components")) patterns.styling = "styled-components";
+    else if (deps.has("@emotion/react")) patterns.styling = "emotion";
+    else if (this.hasFile("*.module.css")) patterns.styling = "css-modules";
+    if (deps.has("vitest")) patterns.testing = "vitest";
+    else if (deps.has("jest")) patterns.testing = "jest";
+    else if (deps.has("@playwright/test")) patterns.testing = "playwright";
+    else if (deps.has("cypress")) patterns.testing = "cypress";
+    if (deps.has("@biomejs/biome")) patterns.linting = "biome";
+    else if (deps.has("eslint")) patterns.linting = "eslint";
+    if (deps.has("@biomejs/biome")) patterns.formatting = "biome";
+    else if (deps.has("prettier")) patterns.formatting = "prettier";
+    return patterns;
+  }
+  /**
+   * Detect project type
+   */
+  detectProjectType() {
+    const deps = this.getDependencies();
+    if (deps.has("react-native") || deps.has("expo")) return "mobile";
+    if (deps.has("electron") || deps.has("@tauri-apps/api")) return "desktop";
+    if (deps.has("next") || deps.has("nuxt") || deps.has("remix")) return "web-app";
+    if (deps.has("express") || deps.has("fastify") || deps.has("hono")) return "api";
+    if (deps.has("commander") || deps.has("clipanion") || deps.has("yargs")) return "cli";
+    if (this.hasFile("rollup.config.js") || this.hasFile("tsup.config.ts")) return "library";
+    if (deps.has("react") || deps.has("vue") || deps.has("svelte")) return "web-app";
+    return "unknown";
+  }
+  /**
+   * Get project name
+   */
+  getProjectName() {
+    if (this.packageJson && typeof this.packageJson.name === "string") {
+      return this.packageJson.name;
+    }
+    return basename7(this.projectPath);
+  }
+  /**
+   * Get project description
+   */
+  getProjectDescription() {
+    if (this.packageJson && typeof this.packageJson.description === "string") {
+      return this.packageJson.description;
+    }
+    return void 0;
+  }
+  // Private helpers
+  loadPackageJson() {
+    const packageJsonPath = join7(this.projectPath, "package.json");
+    if (existsSync8(packageJsonPath)) {
+      try {
+        const content = readFileSync4(packageJsonPath, "utf-8");
+        this.packageJson = JSON.parse(content);
+      } catch {
+        this.packageJson = null;
+      }
+    }
+  }
+  scanFiles() {
+    try {
+      const entries = readdirSync2(this.projectPath, { withFileTypes: true });
+      for (const entry of entries) {
+        this.files.add(entry.name);
+        if (entry.isDirectory() && !entry.name.startsWith(".") && entry.name !== "node_modules") {
+          try {
+            const subEntries = readdirSync2(join7(this.projectPath, entry.name));
+            for (const subEntry of subEntries) {
+              this.files.add(`${entry.name}/${subEntry}`);
+            }
+          } catch {
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  getDependencies() {
+    const deps = /* @__PURE__ */ new Set();
+    if (!this.packageJson) return deps;
+    const dependencies = this.packageJson.dependencies;
+    const devDependencies = this.packageJson.devDependencies;
+    if (dependencies) {
+      for (const dep of Object.keys(dependencies)) {
+        deps.add(dep);
+      }
+    }
+    if (devDependencies) {
+      for (const dep of Object.keys(devDependencies)) {
+        deps.add(dep);
+      }
+    }
+    return deps;
+  }
+  getVersion(depName) {
+    if (!this.packageJson) return void 0;
+    const dependencies = this.packageJson.dependencies;
+    const devDependencies = this.packageJson.devDependencies;
+    const version = dependencies?.[depName] || devDependencies?.[depName];
+    if (version) {
+      return version.replace(/^[\^~>=<]+/, "");
+    }
+    return void 0;
+  }
+  hasFile(pattern) {
+    if (pattern.includes("*")) {
+      const regex = new RegExp(pattern.replace(/\*/g, ".*"));
+      for (const file of this.files) {
+        if (regex.test(file)) return true;
+      }
+      return false;
+    }
+    return this.files.has(pattern);
+  }
+  detectLanguages() {
+    const languages = [];
+    if (this.hasFile("tsconfig.json") || this.files.has("*.ts")) {
+      const tsVersion = this.getVersion("typescript");
+      languages.push({
+        name: "typescript",
+        version: tsVersion,
+        confidence: 100,
+        source: "tsconfig.json"
+      });
+    }
+    if (this.hasFile("jsconfig.json") || this.packageJson && !this.hasFile("tsconfig.json")) {
+      languages.push({
+        name: "javascript",
+        confidence: 90,
+        source: "package.json"
+      });
+    }
+    if (this.hasFile("pyproject.toml") || this.hasFile("requirements.txt")) {
+      languages.push({
+        name: "python",
+        confidence: 100,
+        source: "pyproject.toml"
+      });
+    }
+    if (this.hasFile("Cargo.toml")) {
+      languages.push({
+        name: "rust",
+        confidence: 100,
+        source: "Cargo.toml"
+      });
+    }
+    if (this.hasFile("go.mod")) {
+      languages.push({
+        name: "go",
+        confidence: 100,
+        source: "go.mod"
+      });
+    }
+    return languages;
+  }
+  detectRuntime() {
+    const runtime = [];
+    if (this.packageJson) {
+      const engines = this.packageJson.engines;
+      const nodeVersion = engines?.node;
+      runtime.push({
+        name: "nodejs",
+        version: nodeVersion?.replace(/[>=<^~]+/g, ""),
+        confidence: 100,
+        source: "package.json"
+      });
+    }
+    if (this.hasFile("bun.lockb") || this.hasFile("bunfig.toml")) {
+      runtime.push({
+        name: "bun",
+        confidence: 100,
+        source: "bun.lockb"
+      });
+    }
+    if (this.hasFile("deno.json") || this.hasFile("deno.jsonc")) {
+      runtime.push({
+        name: "deno",
+        confidence: 100,
+        source: "deno.json"
+      });
+    }
+    return runtime;
+  }
+  detectFromPatterns(patterns) {
+    const detected = [];
+    const deps = this.getDependencies();
+    for (const [name, pattern] of Object.entries(patterns)) {
+      let found = false;
+      let source;
+      if (pattern.dependencies) {
+        for (const dep of pattern.dependencies) {
+          if (deps.has(dep)) {
+            found = true;
+            source = "package.json";
+            break;
+          }
+        }
+      }
+      if (!found && pattern.files) {
+        for (const file of pattern.files) {
+          if (this.hasFile(file)) {
+            found = true;
+            source = file;
+            break;
+          }
+        }
+      }
+      if (found) {
+        const version = pattern.dependencies ? this.getVersion(pattern.dependencies[0]) : void 0;
+        detected.push({
+          name,
+          version,
+          confidence: 100,
+          source
+        });
+      }
+    }
+    return detected;
+  }
+};
+function analyzeProject(projectPath) {
+  const detector = new ProjectDetector(projectPath);
+  return detector.analyze();
+}
+function getStackTags(stack) {
+  const tags = /* @__PURE__ */ new Set();
+  const addTags = (detections, patterns) => {
+    for (const detection of detections) {
+      const pattern = patterns[detection.name];
+      if (pattern?.tags) {
+        for (const tag of pattern.tags) {
+          tags.add(tag);
+        }
+      } else {
+        tags.add(detection.name);
+      }
+    }
+  };
+  for (const lang of stack.languages) {
+    tags.add(lang.name);
+  }
+  addTags(stack.frameworks, FRAMEWORK_PATTERNS);
+  addTags(stack.libraries, LIBRARY_PATTERNS);
+  addTags(stack.styling, STYLING_PATTERNS);
+  addTags(stack.testing, TESTING_PATTERNS);
+  addTags(stack.databases, DATABASE_PATTERNS);
+  return Array.from(tags);
+}
+
+// src/context/manager.ts
+import { existsSync as existsSync9, readFileSync as readFileSync5, writeFileSync as writeFileSync3, mkdirSync as mkdirSync3 } from "fs";
+import { join as join8 } from "path";
+import { parse as parseYaml5, stringify as stringifyYaml4 } from "yaml";
+var ContextManager = class {
+  projectPath;
+  context = null;
+  constructor(projectPath = process.cwd()) {
+    this.projectPath = projectPath;
+  }
+  /**
+   * Get the context file path
+   */
+  getContextPath() {
+    return join8(this.projectPath, CONTEXT_FILE);
+  }
+  /**
+   * Check if context exists
+   */
+  exists() {
+    return existsSync9(this.getContextPath());
+  }
+  /**
+   * Load context from file
+   */
+  load() {
+    const contextPath = this.getContextPath();
+    if (!existsSync9(contextPath)) {
+      return null;
+    }
+    try {
+      const content = readFileSync5(contextPath, "utf-8");
+      const data = parseYaml5(content);
+      const parsed = ProjectContext.safeParse(data);
+      if (parsed.success) {
+        this.context = parsed.data;
+        return this.context;
+      }
+      console.warn("Context file exists but failed schema validation");
+      return null;
+    } catch (error) {
+      console.warn("Failed to load context:", error);
+      return null;
+    }
+  }
+  /**
+   * Save context to file
+   */
+  save(context) {
+    const contextPath = this.getContextPath();
+    const contextDir = join8(this.projectPath, CONTEXT_DIR);
+    if (!existsSync9(contextDir)) {
+      mkdirSync3(contextDir, { recursive: true });
+    }
+    context.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const content = stringifyYaml4(context, {
+      lineWidth: 0,
+      defaultKeyType: "PLAIN"
+    });
+    writeFileSync3(contextPath, content, "utf-8");
+    this.context = context;
+  }
+  /**
+   * Initialize a new context from project detection
+   */
+  init(options = {}) {
+    if (this.exists() && !options.force) {
+      const existing = this.load();
+      if (existing) {
+        return existing;
+      }
+    }
+    const detector = new ProjectDetector(this.projectPath);
+    const stack = options.skipDetection ? this.getEmptyStack() : detector.analyze();
+    const patterns = options.skipDetection ? {} : detector.detectPatterns();
+    const projectType = options.skipDetection ? "unknown" : detector.detectProjectType();
+    const projectName = detector.getProjectName();
+    const projectDescription = detector.getProjectDescription();
+    const context = {
+      version: 1,
+      project: {
+        name: projectName,
+        description: projectDescription,
+        type: projectType,
+        path: this.projectPath
+      },
+      stack,
+      patterns,
+      skills: {
+        installed: [],
+        recommended: [],
+        excluded: [],
+        autoSync: true,
+        securityLevel: "medium",
+        testingRequired: false
+      },
+      agents: {
+        primary: void 0,
+        detected: [],
+        synced: [],
+        disabled: []
+      },
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    this.save(context);
+    return context;
+  }
+  /**
+   * Update context with new detection
+   */
+  refresh() {
+    const existing = this.load();
+    const detector = new ProjectDetector(this.projectPath);
+    const stack = detector.analyze();
+    const patterns = detector.detectPatterns();
+    const projectType = detector.detectProjectType();
+    if (existing) {
+      const merged = {
+        ...existing,
+        stack,
+        patterns,
+        project: {
+          ...existing.project,
+          type: projectType
+        },
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      this.save(merged);
+      return merged;
+    }
+    return this.init();
+  }
+  /**
+   * Get current context (load if not loaded)
+   */
+  get() {
+    if (this.context) {
+      return this.context;
+    }
+    return this.load();
+  }
+  /**
+   * Update skills in context
+   */
+  updateSkills(skills) {
+    const context = this.get();
+    if (!context) {
+      throw new Error("No context found. Run `skillkit context init` first.");
+    }
+    context.skills = {
+      ...context.skills,
+      ...skills
+    };
+    this.save(context);
+  }
+  /**
+   * Update agents in context
+   */
+  updateAgents(agents) {
+    const context = this.get();
+    if (!context) {
+      throw new Error("No context found. Run `skillkit context init` first.");
+    }
+    context.agents = {
+      ...context.agents,
+      ...agents
+    };
+    this.save(context);
+  }
+  /**
+   * Set primary agent
+   */
+  setPrimaryAgent(agent) {
+    this.updateAgents({ primary: agent });
+  }
+  /**
+   * Add agent to synced list
+   */
+  addSyncedAgent(agent) {
+    const context = this.get();
+    if (!context) {
+      throw new Error("No context found");
+    }
+    const synced = new Set(context.agents?.synced || []);
+    synced.add(agent);
+    this.updateAgents({ synced: Array.from(synced) });
+  }
+  /**
+   * Remove agent from synced list
+   */
+  removeSyncedAgent(agent) {
+    const context = this.get();
+    if (!context) {
+      throw new Error("No context found");
+    }
+    const synced = new Set(context.agents?.synced || []);
+    synced.delete(agent);
+    this.updateAgents({ synced: Array.from(synced) });
+  }
+  /**
+   * Add installed skill
+   */
+  addInstalledSkill(skillName) {
+    const context = this.get();
+    if (!context) return;
+    const installed = new Set(context.skills?.installed || []);
+    installed.add(skillName);
+    this.updateSkills({ installed: Array.from(installed) });
+  }
+  /**
+   * Remove installed skill
+   */
+  removeInstalledSkill(skillName) {
+    const context = this.get();
+    if (!context) return;
+    const installed = new Set(context.skills?.installed || []);
+    installed.delete(skillName);
+    this.updateSkills({ installed: Array.from(installed) });
+  }
+  /**
+   * Export context to file
+   */
+  export(options = {}) {
+    const context = this.get();
+    if (!context) {
+      throw new Error("No context found");
+    }
+    const exported = { ...context };
+    if (!options.includeSkills) {
+      delete exported.skills;
+    }
+    if (!options.includeAgents) {
+      delete exported.agents;
+    }
+    if (options.format === "json") {
+      return JSON.stringify(exported, null, 2);
+    }
+    return stringifyYaml4(exported, {
+      lineWidth: 0,
+      defaultKeyType: "PLAIN"
+    });
+  }
+  /**
+   * Import context from content
+   */
+  import(content, options = {}) {
+    let data;
+    try {
+      data = JSON.parse(content);
+    } catch {
+      data = parseYaml5(content);
+    }
+    const parsed = ProjectContext.safeParse(data);
+    if (!parsed.success) {
+      throw new Error(`Invalid context format: ${parsed.error.message}`);
+    }
+    const imported = parsed.data;
+    if (options.merge && this.exists()) {
+      const existing = this.load();
+      const merged = this.mergeContexts(existing, imported);
+      this.save(merged);
+      return merged;
+    }
+    if (!options.overwrite && this.exists()) {
+      throw new Error("Context already exists. Use --merge or --overwrite.");
+    }
+    this.save(imported);
+    return imported;
+  }
+  /**
+   * Merge two contexts
+   */
+  mergeContexts(existing, imported) {
+    return {
+      version: 1,
+      project: {
+        ...existing.project,
+        ...imported.project
+      },
+      stack: this.mergeStacks(existing.stack, imported.stack),
+      patterns: {
+        ...existing.patterns,
+        ...imported.patterns
+      },
+      skills: {
+        installed: [.../* @__PURE__ */ new Set([...existing.skills?.installed || [], ...imported.skills?.installed || []])],
+        recommended: [.../* @__PURE__ */ new Set([...existing.skills?.recommended || [], ...imported.skills?.recommended || []])],
+        excluded: [.../* @__PURE__ */ new Set([...existing.skills?.excluded || [], ...imported.skills?.excluded || []])],
+        autoSync: imported.skills?.autoSync ?? existing.skills?.autoSync ?? true,
+        securityLevel: imported.skills?.securityLevel ?? existing.skills?.securityLevel ?? "medium",
+        testingRequired: imported.skills?.testingRequired ?? existing.skills?.testingRequired ?? false
+      },
+      agents: {
+        primary: imported.agents?.primary ?? existing.agents?.primary,
+        detected: [.../* @__PURE__ */ new Set([...existing.agents?.detected || [], ...imported.agents?.detected || []])],
+        synced: [.../* @__PURE__ */ new Set([...existing.agents?.synced || [], ...imported.agents?.synced || []])],
+        disabled: [.../* @__PURE__ */ new Set([...existing.agents?.disabled || [], ...imported.agents?.disabled || []])]
+      },
+      createdAt: existing.createdAt,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  /**
+   * Merge two stacks
+   */
+  mergeStacks(existing, imported) {
+    const mergeArrays = (a, b) => {
+      const names = new Set(a.map((item) => item.name));
+      const result = [...a];
+      for (const item of b) {
+        if (!names.has(item.name)) {
+          result.push(item);
+        }
+      }
+      return result;
+    };
+    return {
+      languages: mergeArrays(existing.languages, imported.languages),
+      frameworks: mergeArrays(existing.frameworks, imported.frameworks),
+      libraries: mergeArrays(existing.libraries, imported.libraries),
+      styling: mergeArrays(existing.styling, imported.styling),
+      testing: mergeArrays(existing.testing, imported.testing),
+      databases: mergeArrays(existing.databases, imported.databases),
+      tools: mergeArrays(existing.tools, imported.tools),
+      runtime: mergeArrays(existing.runtime, imported.runtime)
+    };
+  }
+  /**
+   * Get empty stack
+   */
+  getEmptyStack() {
+    return {
+      languages: [],
+      frameworks: [],
+      libraries: [],
+      styling: [],
+      testing: [],
+      databases: [],
+      tools: [],
+      runtime: []
+    };
+  }
+  /**
+   * Get recommended skill tags based on stack
+   */
+  getRecommendedTags() {
+    const context = this.get();
+    if (!context) return [];
+    return getStackTags(context.stack);
+  }
+};
+function createContextManager(projectPath) {
+  return new ContextManager(projectPath);
+}
+function loadContext(projectPath) {
+  const manager = new ContextManager(projectPath);
+  return manager.load();
+}
+function initContext(projectPath, options) {
+  const manager = new ContextManager(projectPath);
+  return manager.init(options);
+}
+
+// src/context/sync.ts
+import { existsSync as existsSync10, writeFileSync as writeFileSync4, mkdirSync as mkdirSync4, copyFileSync, readdirSync as readdirSync3 } from "fs";
+import { join as join9 } from "path";
+var AGENT_DIRS = {
+  "claude-code": { skillsDir: ".claude/skills", configFile: "AGENTS.md" },
+  "cursor": { skillsDir: ".cursor/skills", configFile: ".cursorrules" },
+  "codex": { skillsDir: ".codex/skills", configFile: "AGENTS.md" },
+  "gemini-cli": { skillsDir: ".gemini/skills", configFile: "GEMINI.md" },
+  "opencode": { skillsDir: ".opencode/skills", configFile: "AGENTS.md" },
+  "antigravity": { skillsDir: ".antigravity/skills", configFile: "AGENTS.md" },
+  "amp": { skillsDir: ".agents/skills", configFile: "AGENTS.md" },
+  "clawdbot": { skillsDir: "skills", configFile: "AGENTS.md" },
+  "droid": { skillsDir: ".factory/skills", configFile: "AGENTS.md" },
+  "github-copilot": { skillsDir: ".github/skills", configFile: "AGENTS.md" },
+  "goose": { skillsDir: ".goose/skills", configFile: "AGENTS.md" },
+  "kilo": { skillsDir: ".kilocode/skills", configFile: "AGENTS.md" },
+  "kiro-cli": { skillsDir: ".kiro/skills", configFile: "AGENTS.md" },
+  "roo": { skillsDir: ".roo/skills", configFile: "AGENTS.md" },
+  "trae": { skillsDir: ".trae/skills", configFile: "AGENTS.md" },
+  "windsurf": { skillsDir: ".windsurf/skills", configFile: "AGENTS.md" },
+  "universal": { skillsDir: ".agent/skills", configFile: "AGENTS.md" }
+};
+var ContextSync = class {
+  projectPath;
+  contextManager;
+  constructor(projectPath = process.cwd()) {
+    this.projectPath = projectPath;
+    this.contextManager = new ContextManager(projectPath);
+  }
+  /**
+   * Detect which agents are installed/configured on the system
+   */
+  detectAgents() {
+    const detected = [];
+    for (const [agent, config] of Object.entries(AGENT_DIRS)) {
+      const skillsPath = join9(this.projectPath, config.skillsDir);
+      const configPath = join9(this.projectPath, config.configFile);
+      if (existsSync10(skillsPath) || existsSync10(configPath)) {
+        detected.push(agent);
+      }
+    }
+    const homeDir = process.env.HOME || process.env.USERPROFILE || "";
+    if (homeDir) {
+      if (existsSync10(join9(homeDir, ".claude"))) {
+        if (!detected.includes("claude-code")) detected.push("claude-code");
+      }
+      if (existsSync10(join9(homeDir, ".cursor"))) {
+        if (!detected.includes("cursor")) detected.push("cursor");
+      }
+    }
+    return detected;
+  }
+  /**
+   * Get agents to sync to based on context
+   */
+  getTargetAgents(options = {}) {
+    if (options.agents?.length) {
+      return options.agents;
+    }
+    const context = this.contextManager.get();
+    if (context?.agents?.synced?.length) {
+      return context.agents.synced;
+    }
+    return this.detectAgents();
+  }
+  /**
+   * Sync all skills to all target agents
+   */
+  async syncAll(options = {}) {
+    const targetAgents = this.getTargetAgents(options);
+    const results = [];
+    const skills = this.getSourceSkills();
+    for (const agent of targetAgents) {
+      const result = await this.syncToAgent(agent, skills, options);
+      results.push(result);
+    }
+    if (!options.dryRun) {
+      this.contextManager.updateAgents({
+        detected: this.detectAgents(),
+        synced: targetAgents
+      });
+    }
+    return {
+      totalAgents: targetAgents.length,
+      successfulAgents: results.filter((r) => r.success).length,
+      totalSkills: skills.length,
+      results
+    };
+  }
+  /**
+   * Sync skills to a specific agent
+   */
+  async syncToAgent(agent, skills, options = {}) {
+    const result = {
+      success: true,
+      agent,
+      skillsSynced: 0,
+      skillsSkipped: 0,
+      errors: [],
+      warnings: [],
+      files: []
+    };
+    const sourceSkills = skills || this.getSourceSkills();
+    const agentConfig = AGENT_DIRS[agent];
+    if (!agentConfig) {
+      result.success = false;
+      result.errors.push(`Unknown agent: ${agent}`);
+      return result;
+    }
+    const targetDir = join9(this.projectPath, agentConfig.skillsDir);
+    if (!options.dryRun && !existsSync10(targetDir)) {
+      mkdirSync4(targetDir, { recursive: true });
+    }
+    for (const skill of sourceSkills) {
+      try {
+        const skillResult = await this.syncSkill(skill, agent, targetDir, options);
+        if (skillResult.synced) {
+          result.skillsSynced++;
+          result.files.push(skillResult.file);
+        } else {
+          result.skillsSkipped++;
+          if (skillResult.warning) {
+            result.warnings.push(skillResult.warning);
+          }
+        }
+      } catch (error) {
+        result.errors.push(`Failed to sync ${skill.name}: ${error}`);
+        result.skillsSkipped++;
+      }
+    }
+    if (result.errors.length > 0) {
+      result.success = false;
+    }
+    return result;
+  }
+  /**
+   * Sync a single skill to an agent
+   */
+  async syncSkill(skill, agent, targetDir, options) {
+    const skillMdPath = join9(skill.path, "SKILL.md");
+    if (!existsSync10(skillMdPath)) {
+      return { synced: false, warning: `No SKILL.md found for ${skill.name}` };
+    }
+    const translation = translateSkillFile(skillMdPath, agent, {
+      addMetadata: true
+    });
+    if (!translation.success) {
+      return { synced: false, warning: `Translation failed for ${skill.name}` };
+    }
+    const targetSkillDir = join9(targetDir, skill.name);
+    const outputPath = join9(targetSkillDir, translation.filename);
+    if (existsSync10(outputPath) && !options.force) {
+      return { synced: false, warning: `${skill.name} already exists (use --force to overwrite)` };
+    }
+    if (!options.dryRun) {
+      if (!existsSync10(targetSkillDir)) {
+        mkdirSync4(targetSkillDir, { recursive: true });
+      }
+      writeFileSync4(outputPath, translation.content, "utf-8");
+      await this.copySkillAssets(skill.path, targetSkillDir);
+    }
+    return { synced: true, file: outputPath };
+  }
+  /**
+   * Copy additional skill assets (references, scripts, etc.)
+   */
+  async copySkillAssets(sourcePath, targetPath) {
+    const assetDirs = ["references", "scripts", "assets", "templates"];
+    for (const assetDir of assetDirs) {
+      const sourceAssetDir = join9(sourcePath, assetDir);
+      if (existsSync10(sourceAssetDir)) {
+        const targetAssetDir = join9(targetPath, assetDir);
+        if (!existsSync10(targetAssetDir)) {
+          mkdirSync4(targetAssetDir, { recursive: true });
+        }
+        try {
+          const files = readdirSync3(sourceAssetDir);
+          for (const file of files) {
+            const sourcefile = join9(sourceAssetDir, file);
+            const targetFile = join9(targetAssetDir, file);
+            copyFileSync(sourcefile, targetFile);
+          }
+        } catch {
+        }
+      }
+    }
+  }
+  /**
+   * Get source skills to sync
+   */
+  getSourceSkills() {
+    const context = this.contextManager.get();
+    const primaryAgent = context?.agents?.primary;
+    const searchDirs = [];
+    if (primaryAgent && AGENT_DIRS[primaryAgent]) {
+      searchDirs.push(join9(this.projectPath, AGENT_DIRS[primaryAgent].skillsDir));
+    }
+    const commonDirs = [
+      ".claude/skills",
+      ".cursor/skills",
+      ".agent/skills",
+      "skills"
+    ];
+    for (const dir of commonDirs) {
+      const fullPath = join9(this.projectPath, dir);
+      if (!searchDirs.includes(fullPath) && existsSync10(fullPath)) {
+        searchDirs.push(fullPath);
+      }
+    }
+    const skills = findAllSkills(searchDirs);
+    return skills.map((s) => ({ name: s.name, path: s.path }));
+  }
+  /**
+   * Check sync status - which agents have which skills
+   */
+  checkStatus() {
+    const status = {};
+    for (const [agent, config] of Object.entries(AGENT_DIRS)) {
+      const skillsPath = join9(this.projectPath, config.skillsDir);
+      const skills = [];
+      if (existsSync10(skillsPath)) {
+        try {
+          const entries = readdirSync3(skillsPath, { withFileTypes: true });
+          for (const entry of entries) {
+            if (entry.isDirectory()) {
+              skills.push(entry.name);
+            }
+          }
+        } catch {
+        }
+      }
+      status[agent] = {
+        hasSkills: skills.length > 0,
+        skillCount: skills.length,
+        skills
+      };
+    }
+    return status;
+  }
+};
+function createContextSync(projectPath) {
+  return new ContextSync(projectPath);
+}
+async function syncToAllAgents(projectPath, options) {
+  const sync = new ContextSync(projectPath);
+  return sync.syncAll(options);
+}
+async function syncToAgent(agent, projectPath, options) {
+  const sync = new ContextSync(projectPath);
+  return sync.syncToAgent(agent, void 0, options);
+}
+
+// src/recommend/types.ts
+import { z as z4 } from "zod";
+var SkillSummary = z4.object({
+  name: z4.string(),
+  description: z4.string().optional(),
+  source: z4.string().optional(),
+  // Repository source
+  tags: z4.array(z4.string()).default([]),
+  compatibility: z4.object({
+    frameworks: z4.array(z4.string()).default([]),
+    languages: z4.array(z4.string()).default([]),
+    libraries: z4.array(z4.string()).default([]),
+    minVersion: z4.record(z4.string()).optional()
+    // { "react": "18.0.0" }
+  }).optional(),
+  popularity: z4.number().default(0),
+  // Downloads/stars
+  quality: z4.number().min(0).max(100).default(50),
+  // Quality score
+  lastUpdated: z4.string().datetime().optional(),
+  verified: z4.boolean().default(false)
+});
+var DEFAULT_SCORING_WEIGHTS = {
+  framework: 40,
+  language: 20,
+  library: 15,
+  tag: 10,
+  popularity: 5,
+  quality: 5,
+  freshness: 5
+};
+var TAG_TO_TECH = {
+  // Frontend frameworks
+  react: ["react", "react-dom", "@types/react"],
+  vue: ["vue", "@vue/core"],
+  angular: ["@angular/core"],
+  svelte: ["svelte"],
+  solid: ["solid-js"],
+  qwik: ["@builder.io/qwik"],
+  // Meta-frameworks
+  nextjs: ["next"],
+  nuxt: ["nuxt"],
+  remix: ["@remix-run/react"],
+  astro: ["astro"],
+  gatsby: ["gatsby"],
+  sveltekit: ["@sveltejs/kit"],
+  // Backend
+  express: ["express"],
+  fastify: ["fastify"],
+  koa: ["koa"],
+  hono: ["hono"],
+  nestjs: ["@nestjs/core"],
+  fastapi: ["fastapi"],
+  django: ["django"],
+  flask: ["flask"],
+  // Languages
+  typescript: ["typescript", "@types/node"],
+  javascript: [],
+  // Inferred from lack of typescript
+  python: [],
+  rust: [],
+  go: [],
+  // Styling
+  tailwind: ["tailwindcss"],
+  "styled-components": ["styled-components"],
+  emotion: ["@emotion/react"],
+  "css-modules": [],
+  sass: ["sass", "node-sass"],
+  // State management
+  redux: ["@reduxjs/toolkit", "redux"],
+  zustand: ["zustand"],
+  mobx: ["mobx"],
+  jotai: ["jotai"],
+  recoil: ["recoil"],
+  // Testing
+  jest: ["jest"],
+  vitest: ["vitest"],
+  playwright: ["@playwright/test"],
+  cypress: ["cypress"],
+  testing: ["@testing-library/react"],
+  // Databases
+  postgres: ["pg", "@prisma/client"],
+  mongodb: ["mongoose", "mongodb"],
+  supabase: ["@supabase/supabase-js"],
+  firebase: ["firebase"],
+  prisma: ["@prisma/client"],
+  drizzle: ["drizzle-orm"],
+  // Tools
+  eslint: ["eslint"],
+  prettier: ["prettier"],
+  biome: ["@biomejs/biome"],
+  turborepo: ["turbo"],
+  monorepo: ["lerna", "nx"],
+  // API
+  graphql: ["graphql", "@apollo/client"],
+  trpc: ["@trpc/server"],
+  rest: [],
+  // Auth
+  auth: ["next-auth", "@auth/core", "passport"],
+  "better-auth": ["better-auth"],
+  // Deployment
+  vercel: ["vercel"],
+  docker: [],
+  kubernetes: [],
+  // Other
+  ai: ["openai", "@anthropic-ai/sdk", "ai"],
+  shadcn: [],
+  security: [],
+  performance: [],
+  accessibility: []
+};
+function getTechTags(techName) {
+  const tags = [];
+  for (const [tag, techs] of Object.entries(TAG_TO_TECH)) {
+    if (techs.includes(techName)) {
+      tags.push(tag);
+    }
+  }
+  return tags;
+}
+
+// src/recommend/engine.ts
+var RecommendationEngine = class {
+  weights;
+  index = null;
+  constructor(weights) {
+    this.weights = { ...DEFAULT_SCORING_WEIGHTS, ...weights };
+  }
+  /**
+   * Load skill index from cache or generate from local skills
+   */
+  loadIndex(index) {
+    this.index = index;
+  }
+  /**
+   * Get loaded index
+   */
+  getIndex() {
+    return this.index;
+  }
+  /**
+   * Score a single skill against a project profile
+   */
+  scoreSkill(profile, skill) {
+    const reasons = [];
+    const warnings = [];
+    let totalScore = 0;
+    const frameworkMatch = this.matchFrameworks(profile.stack, skill);
+    reasons.push(frameworkMatch);
+    totalScore += frameworkMatch.weight;
+    const languageMatch = this.matchLanguages(profile.stack, skill);
+    reasons.push(languageMatch);
+    totalScore += languageMatch.weight;
+    const libraryMatch = this.matchLibraries(profile.stack, skill);
+    reasons.push(libraryMatch);
+    totalScore += libraryMatch.weight;
+    const tagMatch = this.matchTags(profile, skill);
+    reasons.push(tagMatch);
+    totalScore += tagMatch.weight;
+    const popularityScore = this.scorePopularity(skill);
+    reasons.push(popularityScore);
+    totalScore += popularityScore.weight;
+    const qualityScore = this.scoreQuality(skill);
+    reasons.push(qualityScore);
+    totalScore += qualityScore.weight;
+    const freshnessScore = this.scoreFreshness(skill);
+    reasons.push(freshnessScore);
+    totalScore += freshnessScore.weight;
+    if (skill.compatibility?.minVersion) {
+      for (const [tech, minVer] of Object.entries(skill.compatibility.minVersion)) {
+        const detected = this.findDetectedVersion(profile.stack, tech);
+        if (detected && this.isVersionLower(detected, minVer)) {
+          warnings.push(`Requires ${tech} ${minVer}+, you have ${detected}`);
+        }
+      }
+    }
+    if (profile.installedSkills.includes(skill.name)) {
+      warnings.push("Already installed");
+    }
+    return {
+      skill,
+      score: Math.min(100, Math.round(totalScore)),
+      reasons,
+      warnings
+    };
+  }
+  /**
+   * Match frameworks in project stack against skill
+   */
+  matchFrameworks(stack, skill) {
+    const matched = [];
+    const skillFrameworks = skill.compatibility?.frameworks || [];
+    const skillTags = skill.tags || [];
+    for (const detection of stack.frameworks) {
+      const techName = detection.name.toLowerCase();
+      if (skillFrameworks.some((f) => f.toLowerCase() === techName)) {
+        matched.push(detection.name);
+        continue;
+      }
+      const relatedTags = getTechTags(techName);
+      for (const tag of skillTags) {
+        if (relatedTags.includes(tag.toLowerCase()) || tag.toLowerCase() === techName) {
+          matched.push(detection.name);
+          break;
+        }
+      }
+      for (const [tagName, techs] of Object.entries(TAG_TO_TECH)) {
+        if (techs.includes(techName) && skillTags.includes(tagName)) {
+          if (!matched.includes(detection.name)) {
+            matched.push(detection.name);
+          }
+        }
+      }
+    }
+    const ratio = matched.length / Math.max(stack.frameworks.length, 1);
+    const weight = Math.round(this.weights.framework * ratio);
+    return {
+      category: "framework",
+      description: matched.length > 0 ? `Matches frameworks: ${matched.join(", ")}` : "No framework match",
+      weight,
+      matched
+    };
+  }
+  /**
+   * Match languages in project stack against skill
+   */
+  matchLanguages(stack, skill) {
+    const matched = [];
+    const skillLanguages = skill.compatibility?.languages || [];
+    const skillTags = skill.tags || [];
+    for (const detection of stack.languages) {
+      const langName = detection.name.toLowerCase();
+      if (skillLanguages.some((l) => l.toLowerCase() === langName)) {
+        matched.push(detection.name);
+        continue;
+      }
+      if (skillTags.some((t) => t.toLowerCase() === langName)) {
+        matched.push(detection.name);
+      }
+    }
+    const ratio = matched.length / Math.max(stack.languages.length, 1);
+    const weight = Math.round(this.weights.language * ratio);
+    return {
+      category: "language",
+      description: matched.length > 0 ? `Matches languages: ${matched.join(", ")}` : "No language match",
+      weight,
+      matched
+    };
+  }
+  /**
+   * Match libraries in project stack against skill
+   */
+  matchLibraries(stack, skill) {
+    const matched = [];
+    const skillLibraries = skill.compatibility?.libraries || [];
+    const skillTags = skill.tags || [];
+    const allLibraries = [...stack.libraries, ...stack.styling, ...stack.testing, ...stack.databases];
+    for (const detection of allLibraries) {
+      const libName = detection.name.toLowerCase();
+      if (skillLibraries.some((l) => l.toLowerCase() === libName)) {
+        matched.push(detection.name);
+        continue;
+      }
+      const relatedTags = getTechTags(libName);
+      for (const tag of skillTags) {
+        if (relatedTags.includes(tag.toLowerCase()) || tag.toLowerCase() === libName) {
+          matched.push(detection.name);
+          break;
+        }
+      }
+    }
+    const ratio = matched.length / Math.max(allLibraries.length, 1);
+    const weight = Math.round(this.weights.library * ratio);
+    return {
+      category: "library",
+      description: matched.length > 0 ? `Matches libraries: ${matched.join(", ")}` : "No library match",
+      weight,
+      matched
+    };
+  }
+  /**
+   * Match tags based on project patterns and type
+   */
+  matchTags(profile, skill) {
+    const matched = [];
+    const skillTags = skill.tags || [];
+    const projectTags = this.extractProjectTags(profile);
+    for (const tag of skillTags) {
+      if (projectTags.includes(tag.toLowerCase())) {
+        matched.push(tag);
+      }
+    }
+    const ratio = matched.length / Math.max(skillTags.length, 1);
+    const weight = Math.round(this.weights.tag * ratio);
+    return {
+      category: "tag",
+      description: matched.length > 0 ? `Matches tags: ${matched.join(", ")}` : "No tag match",
+      weight,
+      matched
+    };
+  }
+  /**
+   * Extract relevant tags from project profile
+   */
+  extractProjectTags(profile) {
+    const tags = [];
+    if (profile.type) {
+      tags.push(profile.type.toLowerCase());
+    }
+    if (profile.patterns) {
+      if (profile.patterns.components) tags.push(profile.patterns.components);
+      if (profile.patterns.stateManagement) tags.push(profile.patterns.stateManagement);
+      if (profile.patterns.apiStyle) tags.push(profile.patterns.apiStyle);
+      if (profile.patterns.styling) tags.push(profile.patterns.styling);
+      if (profile.patterns.testing) tags.push(profile.patterns.testing);
+    }
+    const allDetections = [
+      ...profile.stack.frameworks,
+      ...profile.stack.languages,
+      ...profile.stack.libraries,
+      ...profile.stack.styling,
+      ...profile.stack.testing,
+      ...profile.stack.databases,
+      ...profile.stack.tools
+    ];
+    for (const detection of allDetections) {
+      tags.push(detection.name.toLowerCase());
+      const related = getTechTags(detection.name.toLowerCase());
+      tags.push(...related);
+    }
+    return [...new Set(tags)];
+  }
+  /**
+   * Score based on popularity (downloads/stars)
+   */
+  scorePopularity(skill) {
+    const popularity = skill.popularity ?? 0;
+    const normalized = Math.min(popularity / 1e3, 1);
+    const weight = Math.round(this.weights.popularity * normalized);
+    return {
+      category: "popularity",
+      description: popularity > 0 ? `${popularity} downloads/stars` : "No popularity data",
+      weight,
+      matched: popularity > 0 ? [popularity.toString()] : []
+    };
+  }
+  /**
+   * Score based on quality metrics
+   */
+  scoreQuality(skill) {
+    const quality = skill.quality ?? 50;
+    const normalized = quality / 100;
+    const weight = Math.round(this.weights.quality * normalized);
+    return {
+      category: "quality",
+      description: `Quality score: ${skill.quality}/100`,
+      weight,
+      matched: skill.verified ? ["verified"] : []
+    };
+  }
+  /**
+   * Score based on freshness (last update)
+   */
+  scoreFreshness(skill) {
+    if (!skill.lastUpdated) {
+      return {
+        category: "freshness",
+        description: "No update date available",
+        weight: 0,
+        matched: []
+      };
+    }
+    const lastUpdate = new Date(skill.lastUpdated);
+    const now = /* @__PURE__ */ new Date();
+    const daysSinceUpdate = (now.getTime() - lastUpdate.getTime()) / (1e3 * 60 * 60 * 24);
+    let normalized = Math.max(0, 1 - daysSinceUpdate / 365);
+    if (daysSinceUpdate <= 30) normalized = 1;
+    const weight = Math.round(this.weights.freshness * normalized);
+    return {
+      category: "freshness",
+      description: daysSinceUpdate <= 30 ? "Recently updated" : `Updated ${Math.round(daysSinceUpdate)} days ago`,
+      weight,
+      matched: [skill.lastUpdated]
+    };
+  }
+  /**
+   * Find detected version for a technology
+   */
+  findDetectedVersion(stack, tech) {
+    const techLower = tech.toLowerCase();
+    const allDetections = [
+      ...stack.frameworks,
+      ...stack.languages,
+      ...stack.libraries,
+      ...stack.styling,
+      ...stack.testing,
+      ...stack.databases,
+      ...stack.tools,
+      ...stack.runtime
+    ];
+    const found = allDetections.find((d) => d.name.toLowerCase() === techLower);
+    return found?.version || null;
+  }
+  /**
+   * Compare semantic versions (basic implementation)
+   */
+  isVersionLower(current, required) {
+    const parseVersion = (v) => v.replace(/[^0-9.]/g, "").split(".").map(Number);
+    const currentParts = parseVersion(current);
+    const requiredParts = parseVersion(required);
+    for (let i = 0; i < Math.max(currentParts.length, requiredParts.length); i++) {
+      const c = currentParts[i] || 0;
+      const r = requiredParts[i] || 0;
+      if (c < r) return true;
+      if (c > r) return false;
+    }
+    return false;
+  }
+  /**
+   * Get top recommendations for a project profile
+   */
+  recommend(profile, options = {}) {
+    const {
+      limit = 10,
+      minScore = 30,
+      categories,
+      excludeInstalled = true,
+      includeReasons = true
+    } = options;
+    if (!this.index) {
+      return {
+        recommendations: [],
+        profile,
+        totalSkillsScanned: 0,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      };
+    }
+    let skills = this.index.skills;
+    if (categories && categories.length > 0) {
+      skills = skills.filter((s) => s.tags?.some((t) => categories.includes(t)));
+    }
+    const scored = skills.map((skill) => this.scoreSkill(profile, skill));
+    let filtered = scored.filter((s) => s.score >= minScore);
+    if (excludeInstalled) {
+      filtered = filtered.filter((s) => !profile.installedSkills.includes(s.skill.name));
+    }
+    filtered = filtered.filter((s) => !profile.excludedSkills.includes(s.skill.name));
+    filtered.sort((a, b) => b.score - a.score);
+    const recommendations = filtered.slice(0, limit);
+    if (!includeReasons) {
+      recommendations.forEach((r) => {
+        r.reasons = [];
+      });
+    }
+    return {
+      recommendations,
+      profile,
+      totalSkillsScanned: skills.length,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  /**
+   * Search skills by query (task-based search)
+   */
+  search(options) {
+    const { query, limit = 10, semantic = true, filters } = options;
+    if (!this.index) {
+      return [];
+    }
+    const trimmedQuery = query.trim();
+    if (!trimmedQuery) {
+      return [];
+    }
+    const queryTerms = trimmedQuery.toLowerCase().split(/\s+/).filter((t) => t.length > 0);
+    if (queryTerms.length === 0) {
+      return [];
+    }
+    const results = [];
+    for (const skill of this.index.skills) {
+      if (filters?.tags && filters.tags.length > 0) {
+        if (!skill.tags?.some((t) => filters.tags.includes(t))) continue;
+      }
+      if (filters?.verified && !skill.verified) continue;
+      const { relevance, matchedTerms, snippet } = this.calculateRelevance(
+        skill,
+        queryTerms,
+        semantic
+      );
+      if (relevance > 0 && (!filters?.minScore || relevance >= filters.minScore)) {
+        results.push({ skill, relevance, matchedTerms, snippet });
+      }
+    }
+    results.sort((a, b) => b.relevance - a.relevance);
+    return results.slice(0, limit);
+  }
+  /**
+   * Calculate search relevance for a skill
+   */
+  calculateRelevance(skill, queryTerms, semantic) {
+    const matchedTerms = [];
+    let relevance = 0;
+    const nameLower = skill.name.toLowerCase();
+    for (const term of queryTerms) {
+      if (nameLower.includes(term)) {
+        relevance += 40;
+        matchedTerms.push(term);
+      }
+    }
+    const descLower = (skill.description || "").toLowerCase();
+    for (const term of queryTerms) {
+      if (descLower.includes(term) && !matchedTerms.includes(term)) {
+        relevance += 20;
+        matchedTerms.push(term);
+      }
+    }
+    const tagsLower = (skill.tags || []).map((t) => t.toLowerCase());
+    for (const term of queryTerms) {
+      if (tagsLower.some((t) => t.includes(term)) && !matchedTerms.includes(term)) {
+        relevance += 25;
+        matchedTerms.push(term);
+      }
+    }
+    if (semantic) {
+      for (const term of queryTerms) {
+        const relatedTags = getTechTags(term);
+        for (const relatedTag of relatedTags) {
+          if (tagsLower.includes(relatedTag) || nameLower.includes(relatedTag) || descLower.includes(relatedTag)) {
+            if (!matchedTerms.includes(term)) {
+              relevance += 15;
+              matchedTerms.push(term);
+            }
+          }
+        }
+        const tagTechs = TAG_TO_TECH[term] || [];
+        for (const tech of tagTechs) {
+          if (skill.compatibility?.libraries?.includes(tech)) {
+            if (!matchedTerms.includes(term)) {
+              relevance += 15;
+              matchedTerms.push(term);
+            }
+          }
+        }
+      }
+    }
+    let snippet;
+    if (skill.description && matchedTerms.length > 0) {
+      snippet = skill.description.slice(0, 150);
+      if (skill.description.length > 150) snippet += "...";
+    }
+    relevance = Math.min(100, relevance);
+    return { relevance, matchedTerms, snippet };
+  }
+  /**
+   * Check freshness of installed skills against project dependencies
+   *
+   * A skill is considered:
+   * - 'current': skill's minVersion is <= project version (compatible and up to date)
+   * - 'outdated': skill targets a significantly older major version
+   * - 'unknown': no version requirements specified
+   */
+  checkFreshness(profile, installedSkills) {
+    const results = [];
+    for (const skill of installedSkills) {
+      if (!skill.compatibility?.minVersion) {
+        results.push({
+          skill: skill.name,
+          status: "unknown",
+          details: { message: "No version requirements specified" }
+        });
+        continue;
+      }
+      let status = "current";
+      const messages = [];
+      for (const [tech, minVer] of Object.entries(skill.compatibility.minVersion)) {
+        const detected = this.findDetectedVersion(profile.stack, tech);
+        if (detected) {
+          const majorSkill = parseInt(minVer.split(".")[0]) || 0;
+          const majorProject = parseInt(detected.split(".")[0]) || 0;
+          if (majorProject - majorSkill >= 2) {
+            status = "outdated";
+            messages.push(`Skill targets ${tech} ${minVer}, you have ${detected}`);
+          }
+        }
+      }
+      results.push({
+        skill: skill.name,
+        status,
+        details: messages.length > 0 ? { message: messages.join("; ") } : { message: "Up to date" }
+      });
+    }
+    return results;
+  }
+};
+function createRecommendationEngine(weights) {
+  return new RecommendationEngine(weights);
+}
+export {
+  AGENT_FORMAT_MAP,
+  AgentType,
+  BitbucketProvider,
+  CONTEXT_DIR,
+  CONTEXT_FILE,
+  ContextManager,
+  ContextSync,
+  CopilotTranslator,
+  CursorTranslator,
+  DEFAULT_SCORING_WEIGHTS,
+  GitHubProvider,
+  GitLabProvider,
+  GitProvider,
+  LocalProvider,
+  PROJECT_TYPE_HINTS,
+  ProjectDetector,
+  RecommendationEngine,
+  SKILL_DISCOVERY_PATHS,
+  Skill,
+  SkillFrontmatter,
+  SkillLocation,
+  SkillMdTranslator,
+  SkillMetadata,
+  SkillSummary,
+  SkillkitConfig,
+  TAG_TO_TECH,
+  TranslatorRegistry,
+  WindsurfTranslator,
+  analyzeProject,
+  canTranslate,
+  copilotTranslator,
+  createContextManager,
+  createContextSync,
+  createRecommendationEngine,
+  cursorTranslator,
+  detectProvider,
+  detectSkillFormat,
+  discoverSkills,
+  extractField,
+  extractFrontmatter,
+  findAllSkills,
+  findSkill,
+  getAgentConfigPath,
+  getAllProviders,
+  getGlobalConfigPath,
+  getInstallDir,
+  getProjectConfigPath,
+  getProvider,
+  getSearchDirs,
+  getStackTags,
+  getSupportedTranslationAgents,
+  getTechTags,
+  initContext,
+  initProject,
+  isGitUrl,
+  isLocalPath,
+  isPathInside,
+  loadConfig,
+  loadContext,
+  loadMetadata,
+  loadSkillMetadata,
+  parseShorthand,
+  parseSkill,
+  parseSkillContent,
+  parseSource,
+  readSkillContent,
+  saveConfig,
+  saveSkillMetadata,
+  setSkillEnabled,
+  skillMdTranslator,
+  syncToAgent,
+  syncToAllAgents,
+  translateSkill,
+  translateSkillFile,
+  translatorRegistry,
+  validateSkill,
+  windsurfTranslator
+};
+//# sourceMappingURL=index.js.map