skillmds 1.1.2 → 1.2.1

package/dist/chunk-4BFQJ3YZ.js

@@ -0,0 +1,851 @@
+// src/sources.ts
+import { existsSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+var UNSUPPORTED = (what) => new Error(`${what} sources are not supported yet \u2014 clone it locally and run \`skillmd add ./path/to/skill\`.`);
+function assertSubpath(sub) {
+  if (!sub) return void 0;
+  const clean = sub.replace(/^\/+|\/+$/g, "");
+  if (!clean) return void 0;
+  if (clean.split("/").some((seg) => seg === ".." || seg === "." || seg === "")) {
+    throw new Error(`invalid subpath "${sub}": ".." and empty segments are not allowed`);
+  }
+  return clean;
+}
+function withRef(spec, override) {
+  return override ? { ...spec, ref: override } : spec;
+}
+function parseSource(arg, opts = {}) {
+  const exists = opts.exists ?? existsSync;
+  const a = arg.trim();
+  if (!a) throw new Error("a source is required: owner/name, a GitHub URL, or a local path");
+  if (a === "~" || a.startsWith("~/") || a.startsWith("~\\")) {
+    return { kind: "local", path: join(homedir(), a.slice(1)), display: a };
+  }
+  if (a === "." || a.startsWith("./") || a.startsWith("../") || a.startsWith("/") || /^[a-zA-Z]:[\\/]/.test(a) || a.startsWith("~") || exists(a)) {
+    return { kind: "local", path: a, display: a };
+  }
+  if (/^git@|^ssh:\/\//.test(a)) throw UNSUPPORTED("SSH git");
+  if (/gitlab\.com\//i.test(a) || a.startsWith("gitlab:")) throw UNSUPPORTED("GitLab");
+  const gist = a.match(/^https?:\/\/gist\.github\.com\/([^/]+)\/([0-9a-f]+)\/?$/i);
+  if (gist) return { kind: "gist", user: gist[1], id: gist[2], display: a };
+  const gh = a.match(/^https?:\/\/(?:www\.)?github\.com\/([^/]+)\/([^/#?]+?)(?:\.git)?(?:\/(tree|blob)\/([^/]+)(?:\/(.*?))?)?\/?(?:[#?].*)?$/i);
+  if (gh) {
+    const [, owner2, repo2, mode, ref2, rest] = gh;
+    let sub = rest;
+    if (mode === "blob" && sub) sub = sub.replace(/\/?SKILL\.md$/i, "");
+    return withRef({ kind: "github", owner: owner2, repo: repo2, ref: ref2 || void 0, subpath: assertSubpath(sub), display: a }, opts.ref);
+  }
+  if (/^https?:\/\//.test(a)) throw new Error(`"${a}" is not a supported source (registry slug, GitHub repo/tree/blob URL, gist, or local path)`);
+  const body = a.replace(/^(github|gh):/, "");
+  const prefixed = body !== a;
+  const m = body.match(/^([^/#@\s]+)\/([^/#@\s]+)((?:\/[^#@\s]+)*)?(?:#([^@\s]+))?(?:@([^/\s]+))?$/);
+  if (!m) throw new Error(`"${a}" is not a valid source \u2014 expected owner/name, owner/repo[/sub/path][#ref][@skill], a GitHub URL, or a local path`);
+  const [, owner, repoRaw, subRaw, ref, skill] = m;
+  const repo = repoRaw.replace(/\.git$/, "");
+  const subpath = assertSubpath(subRaw);
+  if (!prefixed && !subpath && !ref && !skill && !opts.ref) return { kind: "slug", owner, name: repo, display: a };
+  return withRef({ kind: "github", owner, repo, ref: ref || void 0, subpath, skill: skill || void 0, display: a }, opts.ref);
+}
+function gigetInput(spec) {
+  return `github:${spec.owner}/${spec.repo}${spec.subpath ? `/${spec.subpath}` : ""}${spec.ref ? `#${spec.ref}` : ""}`;
+}
+function sourceId(spec) {
+  switch (spec.kind) {
+    case "slug":
+      return `registry:${spec.owner}/${spec.name}`;
+    case "github":
+      return `github:${spec.owner}/${spec.repo}${spec.subpath ? `/${spec.subpath}` : ""}${spec.ref ? `#${spec.ref}` : ""}${spec.skill ? `@${spec.skill}` : ""}`;
+    case "gist":
+      return `gist:${spec.user}/${spec.id}`;
+    case "local":
+      return `local:${spec.path}`;
+  }
+}
+
+// src/config.ts
+import { readFileSync, writeFileSync, mkdirSync } from "fs";
+import { homedir as homedir2 } from "os";
+import { join as join2 } from "path";
+var DEFAULT_API = "https://api.skillmd.com";
+function configPath(home = homedir2()) {
+  return join2(home, ".skillmd", "config.json");
+}
+function readConfig(home) {
+  try {
+    return JSON.parse(readFileSync(configPath(home), "utf8"));
+  } catch {
+    return {};
+  }
+}
+function writeConfig(cfg, home = homedir2()) {
+  mkdirSync(join2(home, ".skillmd"), { recursive: true });
+  writeFileSync(configPath(home), JSON.stringify(cfg, null, 2), { encoding: "utf8", mode: 384 });
+}
+function hostOf(url) {
+  try {
+    return new URL(url).host;
+  } catch {
+    return url;
+  }
+}
+var realSources = () => ({ env: process.env, config: readConfig() });
+function resolveApi(flags = {}, src = realSources()) {
+  const base = (flags.api || src.env.SKILLMD_API || src.config.api || DEFAULT_API).replace(/\/+$/, "");
+  if (/^http:\/\//i.test(base) && !flags.insecureHttp) {
+    throw new Error(`refusing to use an http:// API base (${base}) \u2014 your token would travel unencrypted. Use an https:// base, or pass --insecure-http for local development.`);
+  }
+  if (!/^https?:\/\//i.test(base)) throw new Error(`API base must be an http(s) URL, got "${base}"`);
+  return base;
+}
+function resolveToken(flags = {}, src = realSources()) {
+  if (flags.token) return flags.token;
+  if (src.env.SKILLMD_TOKEN) return src.env.SKILLMD_TOKEN;
+  const stored = src.config.token;
+  if (!stored) return void 0;
+  const boundTo = src.config.tokenHost ?? hostOf(DEFAULT_API);
+  const target = hostOf(resolveApi(flags, src));
+  return boundTo === target ? stored : void 0;
+}
+function telemetryDisabled(env = process.env) {
+  const on = (v) => Boolean(v) && v !== "0" && v !== "false";
+  return on(env.SKILLMD_NO_TELEMETRY) || on(env.DO_NOT_TRACK);
+}
+
+// src/api.ts
+import { createHash } from "crypto";
+import { isAllowedSourceUrl } from "@skillmds/core";
+
+// src/limits.ts
+var MAX_PACK_FILES = 200;
+var MAX_PACK_BYTES = 20 * 1024 * 1024;
+var FETCH_TIMEOUT_MS = 3e4;
+var WINDOWS_RESERVED = /^(con|prn|aux|nul|com[1-9]|lpt[1-9])(\.|$)/i;
+
+// src/api.ts
+import { isAllowedSourceUrl as isAllowedSourceUrl2, reconstructSkillMd, skillMdFor } from "@skillmds/core";
+var IntegrityError = class extends Error {
+  integrity = true;
+  constructor(message) {
+    super(message);
+    this.name = "IntegrityError";
+  }
+};
+var RegistryError = class extends Error {
+  constructor(message, status) {
+    super(message);
+    this.status = status;
+    this.name = "RegistryError";
+  }
+  status;
+};
+function timedFetch(f, timeoutMs) {
+  return (input, init = {}) => f(input, { ...init, signal: init.signal ?? AbortSignal.timeout(timeoutMs) });
+}
+function createClient(flags = {}, opts = {}) {
+  const src = opts.sources ?? realSources();
+  const base = resolveApi(flags, src);
+  const token = resolveToken(flags, src);
+  const timeoutMs = opts.timeoutMs ?? FETCH_TIMEOUT_MS;
+  const doFetch = timedFetch(opts.fetch ?? fetch, timeoutMs);
+  const host = hostOf(base);
+  async function api(path, init = {}) {
+    const headers = { accept: "application/json", ...init.headers };
+    if (token) headers.authorization = `Bearer ${token}`;
+    let res;
+    try {
+      res = await doFetch(base + path, { ...init, headers });
+    } catch (e) {
+      const cause = e instanceof Error ? e.cause?.message ?? e.message : String(e);
+      const isTimeout = e instanceof Error && (e.name === "TimeoutError" || e.cause instanceof Error && e.cause.name === "TimeoutError");
+      const why = isTimeout ? `timed out after ${Math.round(timeoutMs / 1e3)}s` : cause;
+      throw new RegistryError(`could not reach ${base}: ${why}`);
+    }
+    if (!res.ok) {
+      const detail = await res.text().catch(() => "");
+      throw new RegistryError(`SkillMD API ${res.status} on ${path}: ${detail}`, res.status);
+    }
+    return await res.json();
+  }
+  return { api, base, host, isDefaultHost: host === hostOf(DEFAULT_API), token, hasToken: Boolean(token), fetch: doFetch };
+}
+async function fetchBundle(base, slug, token, opts = {}) {
+  const doFetch = timedFetch(opts.fetch ?? fetch, opts.timeoutMs ?? FETCH_TIMEOUT_MS);
+  const headers = { accept: "application/json" };
+  if (token) headers.authorization = `Bearer ${token}`;
+  const res = await doFetch(`${base}/api/skills/${slug}/bundle?format=json`, { headers }).catch(() => null);
+  if (!res || !res.ok) return null;
+  const data = await res.json().catch(() => null);
+  if (!data?.files) return null;
+  if (data.files.length > MAX_PACK_FILES) throw new Error(`pack too large: > ${MAX_PACK_FILES} files`);
+  const out = [];
+  let bytes = 0;
+  for (const f of data.files) {
+    let contents;
+    let fromUrl = false;
+    if (f.content_base64 != null) {
+      contents = Buffer.from(f.content_base64, "base64");
+    } else if (f.source_url && isAllowedSourceUrl(f.source_url)) {
+      const r = await doFetch(f.source_url).catch(() => null);
+      if (!r || !r.ok) throw new Error(`could not fetch companion file "${f.path}" from ${hostOf(f.source_url)}`);
+      contents = Buffer.from(await r.arrayBuffer());
+      fromUrl = true;
+    } else {
+      continue;
+    }
+    bytes += contents.length;
+    if (bytes > MAX_PACK_BYTES) throw new Error(`pack too large: > ${Math.round(MAX_PACK_BYTES / (1024 * 1024))}MB`);
+    if (f.sha256) {
+      const got = createHash("sha256").update(contents).digest("hex");
+      if (got !== f.sha256) throw new IntegrityError(`integrity check failed for "${f.path}" (expected ${f.sha256.slice(0, 12)}\u2026, got ${got.slice(0, 12)}\u2026)`);
+    } else if (!fromUrl && f.path !== "SKILL.md") {
+      throw new IntegrityError(`"${f.path}" has no sha256 in the registry bundle \u2014 refusing to install unverifiable content`);
+    }
+    out.push({ path: f.path, contents, ...fromUrl && !f.sha256 ? { unverified: true } : {} });
+  }
+  return out;
+}
+
+// src/source.ts
+import { existsSync as existsSync2, statSync, lstatSync, readFileSync as readFileSync2, readdirSync, mkdtempSync, rmSync } from "fs";
+import { tmpdir } from "os";
+import { join as join3, basename, dirname, relative, sep } from "path";
+var IGNORE_DIRS = /* @__PURE__ */ new Set([
+  // build/dependency dirs
+  "node_modules",
+  ".git",
+  "dist",
+  "build",
+  "out",
+  ".next",
+  ".wrangler",
+  ".cache",
+  ".npm",
+  ".pnpm-store",
+  ".venv",
+  "venv",
+  "__pycache__",
+  "target",
+  "vendor",
+  // large OS / user dirs (mostly relevant when run from a home directory)
+  "AppData",
+  "Library",
+  "$Recycle.Bin",
+  "System Volume Information",
+  "Windows",
+  "Program Files"
+]);
+var MAX_DEPTH = 12;
+function findSkillFiles(dir, depth = 0) {
+  const out = [];
+  if (depth > MAX_DEPTH) return out;
+  let entries;
+  try {
+    entries = readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return out;
+  }
+  for (const entry of entries) {
+    if (entry.isDirectory()) {
+      if (IGNORE_DIRS.has(entry.name)) continue;
+      out.push(...findSkillFiles(join3(dir, entry.name), depth + 1));
+    } else if (entry.name === "SKILL.md") {
+      out.push(join3(dir, entry.name));
+    }
+  }
+  return out;
+}
+function loadLocal(file) {
+  return { path: file, raw: readFileSync2(file, "utf8"), slug: basename(dirname(file)), file };
+}
+async function precheckTreeSize(spec, opts = {}) {
+  const f = timedFetch(opts.fetch ?? fetch, FETCH_TIMEOUT_MS);
+  const ref = spec.ref ?? "HEAD";
+  const res = await f(`https://api.github.com/repos/${spec.owner}/${spec.repo}/git/trees/${encodeURIComponent(ref)}?recursive=1`, {
+    headers: { accept: "application/vnd.github+json", "user-agent": "skillmd-cli" }
+  }).catch(() => null);
+  if (!res || !res.ok) return;
+  const data = await res.json().catch(() => null);
+  if (!data?.tree || data.truncated) return;
+  const prefix = spec.subpath ? `${spec.subpath}/` : "";
+  const blobs = data.tree.filter((t) => t.type === "blob" && (!prefix || t.path.startsWith(prefix)));
+  const bytes = blobs.reduce((n, t) => n + (t.size ?? 0), 0);
+  if (blobs.length > MAX_PACK_FILES) throw new Error(`pack too large: ${blobs.length} files (limit ${MAX_PACK_FILES}) \u2014 point at the skill's own directory (pre-download estimate from the GitHub tree API)`);
+  if (bytes > MAX_PACK_BYTES) throw new Error(`pack too large: ${Math.round(bytes / (1024 * 1024))}MB (limit ${Math.round(MAX_PACK_BYTES / (1024 * 1024))}MB) (pre-download estimate from the GitHub tree API)`);
+}
+function asGithub(spec, ref, display) {
+  if (spec.kind === "github") return spec;
+  return { kind: "github", owner: spec.owner, repo: spec.name, ref, display: display ?? spec.display };
+}
+async function downloadGithub(spec, prefix, opts, precheck) {
+  if (precheck) await precheckTreeSize(spec, opts);
+  const { downloadTemplate } = await import("giget");
+  const tmp = mkdtempSync(join3(tmpdir(), prefix));
+  const cleanup = () => rmSync(tmp, { recursive: true, force: true });
+  try {
+    const { dir } = await downloadTemplate(gigetInput(spec), { dir: tmp, forceClean: true });
+    return { dir, cleanup };
+  } catch (e) {
+    cleanup();
+    const msg = e instanceof Error ? e.message : String(e);
+    throw new Error(`could not download ${spec.display}: ${msg}${/404|Not Found/i.test(msg) ? " (repo, ref or subpath not found \u2014 is it private?)" : ""}`);
+  }
+}
+async function resolveSource(arg, opts = {}) {
+  const spec = parseSource(arg);
+  if (spec.kind === "local") {
+    if (!existsSync2(spec.path)) throw new Error(`Path not found: ${spec.path}`);
+    const st = statSync(spec.path);
+    if (st.isFile()) return [loadLocal(spec.path)];
+    const files = findSkillFiles(spec.path);
+    if (files.length === 0) {
+      throw new Error(`No SKILL.md found under ${spec.path}. Point at a skill directory, e.g. "skillmd lint ./my-skill", or run "skillmd init" to create one.`);
+    }
+    return files.map(loadLocal);
+  }
+  if (spec.kind === "gist") {
+    const f = timedFetch(opts.fetch ?? fetch, FETCH_TIMEOUT_MS);
+    const res = await f(`https://gist.githubusercontent.com/${spec.user}/${spec.id}/raw/SKILL.md`);
+    if (!res.ok) throw new Error(`gist ${spec.id} has no SKILL.md (HTTP ${res.status})`);
+    const tooBig = (n) => new Error(`gist ${spec.id} is too large: ${Math.round(n / (1024 * 1024))}MB (limit ${Math.round(MAX_PACK_BYTES / (1024 * 1024))}MB)`);
+    const declared = Number(res.headers.get("content-length") ?? 0);
+    if (declared > MAX_PACK_BYTES) throw tooBig(declared);
+    const raw = await res.text();
+    if (raw.length > MAX_PACK_BYTES) throw tooBig(raw.length);
+    return [{ path: spec.display, raw, slug: `gist-${spec.id.slice(0, 8)}` }];
+  }
+  const gh = asGithub(spec);
+  const { dir, cleanup } = await downloadGithub(gh, "skillmd-src-", opts, Boolean(gh.subpath));
+  try {
+    let files = findSkillFiles(dir);
+    if (gh.skill) files = files.filter((f) => basename(dirname(f)) === gh.skill);
+    if (files.length === 0) throw new Error(`No SKILL.md found in ${gh.display}${gh.skill ? ` for skill "${gh.skill}"` : ""}`);
+    return files.map((f) => ({ ...loadLocal(f), path: relative(dir, f).split(sep).join("/"), file: void 0 }));
+  } finally {
+    cleanup();
+  }
+}
+function collectFiles(root, dir, limits = {}) {
+  const maxFiles = limits.maxFiles ?? MAX_PACK_FILES;
+  const maxBytes = limits.maxBytes ?? MAX_PACK_BYTES;
+  const out = [];
+  let bytes = 0;
+  const walk = (d, depth) => {
+    if (depth > MAX_DEPTH) return;
+    for (const entry of readdirSync(d, { withFileTypes: true })) {
+      const fp = join3(d, entry.name);
+      const st = lstatSync(fp);
+      if (st.isSymbolicLink()) continue;
+      if (st.isDirectory()) {
+        if (entry.name === ".git" || entry.name === "node_modules") continue;
+        walk(fp, depth + 1);
+      } else if (st.isFile()) {
+        if (out.length >= maxFiles) throw new Error(`pack too large: > ${maxFiles} files`);
+        bytes += st.size;
+        if (bytes > maxBytes) throw new Error(`pack too large: > ${Math.round(maxBytes / (1024 * 1024))}MB`);
+        out.push({ path: relative(root, fp).split(sep).join("/"), contents: readFileSync2(fp) });
+      }
+    }
+  };
+  walk(dir, 0);
+  return out;
+}
+async function resolveTree(sourceUrl, ref, opts = {}) {
+  const spec = parseSource(sourceUrl, { ref });
+  if (spec.kind !== "github" && spec.kind !== "slug") throw new Error(`cannot fetch a tree from ${sourceUrl}`);
+  const gh = asGithub(spec, ref, sourceUrl);
+  const { dir, cleanup } = await downloadGithub(gh, "skillmd-pack-", opts, true);
+  try {
+    return collectFiles(dir, dir);
+  } finally {
+    cleanup();
+  }
+}
+async function resolvePackFiles(skill, fetchTree = resolveTree) {
+  if (!skill.source_repo) return null;
+  const attempts = [{ ref: skill.commit_sha ?? void 0, pinMiss: false }];
+  if (skill.commit_sha) attempts.push({ ref: void 0, pinMiss: true });
+  for (const attempt of attempts) {
+    try {
+      const files = await fetchTree(skill.source_repo, attempt.ref);
+      const sk = files.find((f) => f.path === "SKILL.md");
+      if (sk) return { raw: sk.contents.toString("utf8"), files, pinMiss: attempt.pinMiss };
+    } catch {
+    }
+  }
+  return null;
+}
+
+// src/sanitize.ts
+var CSI = /\x1b\[[0-?]*[ -/]*[@-~]/g;
+var OSC = /\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)/g;
+var ESC_OTHER = /\x1b[@-Z\\-_]/g;
+var C0 = /[\x00-\x08\x0b-\x1f\x7f]/g;
+var C1 = /[\x80-\x9f]/g;
+function stripTerminalEscapes(input) {
+  return input.replace(OSC, "").replace(CSI, "").replace(ESC_OTHER, "").replace(C0, "").replace(C1, "");
+}
+function safeText(input, max = 400) {
+  if (typeof input !== "string") return "";
+  const flat = stripTerminalEscapes(input).replace(/\s*\n\s*/g, " ").trim();
+  if (flat.length <= max) return flat;
+  return `${flat.slice(0, max - 1).trimEnd()}\u2026`;
+}
+
+// src/agents.ts
+import { statSync as statSync2 } from "fs";
+import { homedir as homedir3 } from "os";
+import { join as join4, resolve, isAbsolute } from "path";
+var CANONICAL = [".agents", "skills"];
+var AGENTS = [
+  { id: "claude-code", project: [".claude", "skills"], global: [".claude", "skills"], globalEnv: "CLAUDE_CONFIG_DIR", detect: [[".claude"]], projectRoots: [".claude"] },
+  { id: "cursor", project: [".cursor", "skills"], global: [".cursor", "skills"], detect: [[".cursor"]], projectRoots: [".cursor"] },
+  { id: "codex", project: [".agents", "skills"], global: [".codex", "skills"], globalEnv: "CODEX_HOME", detect: [[".codex"]], projectRoots: [".agents", ".codex"] },
+  { id: "windsurf", project: [".windsurf", "skills"], global: [".codeium", "windsurf", "skills"], detect: [[".codeium", "windsurf"], [".windsurf"]], projectRoots: [".windsurf"] },
+  { id: "opencode", project: [".opencode", "skills"], global: [".config", "opencode", "skills"], detect: [[".config", "opencode"], [".opencode"]], projectRoots: [".opencode"] },
+  { id: "gemini-cli", project: [".gemini", "skills"], global: [".gemini", "skills"], detect: [[".gemini"]], projectRoots: [".gemini", ".agents"] },
+  { id: "antigravity", project: [".agent", "skills"], global: [".gemini", "antigravity", "skills"], detect: [[".gemini", "antigravity"], [".antigravity"]], projectRoots: [".agent", ".agents"] },
+  { id: "kiro", project: [".kiro", "skills"], global: [".kiro", "skills"], detect: [[".kiro"]], projectRoots: [".kiro"] },
+  { id: "warp", project: [".agents", "skills"], global: [".agents", "skills"], detect: [[".warp"]], projectRoots: [".agents"] },
+  { id: "github-copilot", project: [".claude", "skills"], global: [".copilot", "skills"], detect: [[".copilot"]], projectRoots: [".claude", ".github", ".agents"] },
+  { id: "cline", project: [".agents", "skills"], global: [".agents", "skills"], detect: [[".cline"]], projectRoots: [".agents"] },
+  { id: "roo", project: [".roo", "skills"], global: [".roo", "skills"], detect: [[".roo"]], projectRoots: [".roo"] },
+  { id: "goose", project: [".goose", "skills"], global: [".config", "goose", "skills"], detect: [[".config", "goose"]], projectRoots: [".goose"] },
+  { id: "trae", project: [".trae", "skills"], global: [".trae", "skills"], detect: [[".trae"]], projectRoots: [".trae"] },
+  { id: "qwen-code", project: [".qwen", "skills"], global: [".qwen", "skills"], detect: [[".qwen"]], projectRoots: [".qwen"] },
+  { id: "amp", project: [".agents", "skills"], global: [".config", "agents", "skills"], detect: [[".config", "amp"]], projectRoots: [".agents"] },
+  // — extended registry —
+  { id: "openclaw", project: ["skills"], global: [".openclaw", "skills"], detect: [[".openclaw"], [".clawdbot"], [".moltbot"]], projectRoots: [".openclaw"] },
+  { id: "kilo", project: [".claude", "skills"], global: [".kilocode", "skills"], detect: [[".kilocode"]], projectRoots: [".claude", ".kilocode"] },
+  { id: "hermes-agent", project: [".hermes", "skills"], global: [".hermes", "skills"], detect: [[".hermes"]], projectRoots: [".hermes"] },
+  { id: "continue", project: [".continue", "skills"], global: [".continue", "skills"], detect: [[".continue"]], projectRoots: [".continue"] },
+  { id: "devin", project: [".devin", "skills"], global: [".config", "devin", "skills"], detect: [[".config", "devin"]], projectRoots: [".devin"] },
+  { id: "openhands", project: [".openhands", "skills"], global: [".openhands", "skills"], detect: [[".openhands"]], projectRoots: [".openhands"] },
+  { id: "replit", project: [".agents", "skills"], global: [".config", "agents", "skills"], detect: [[".replit"]], projectRoots: [".agents"] },
+  { id: "mistral-vibe", project: [".vibe", "skills"], global: [".vibe", "skills"], detect: [[".vibe"]], projectRoots: [".vibe"] },
+  { id: "zed", project: [".agents", "skills"], global: [".agents", "skills"], detect: [[".config", "zed"]], projectRoots: [".agents"] },
+  { id: "adal", project: [".adal", "skills"], global: [".adal", "skills"], detect: [[".adal"]], projectRoots: [".adal"] },
+  { id: "aider-desk", project: [".aider-desk", "skills"], global: [".aider-desk", "skills"], detect: [[".aider-desk"]], projectRoots: [".aider-desk"] },
+  { id: "antigravity-cli", project: [".agents", "skills"], global: [".gemini", "antigravity-cli", "skills"], detect: [[".gemini", "antigravity-cli"]], projectRoots: [".agents"] },
+  { id: "augment", project: [".augment", "skills"], global: [".augment", "skills"], detect: [[".augment"]], projectRoots: [".augment"] },
+  { id: "autohand-code", project: [".autohand", "skills"], global: [".autohand", "skills"], detect: [[".autohand"]], projectRoots: [".autohand"] },
+  { id: "bob", project: [".bob", "skills"], global: [".bob", "skills"], detect: [[".bob"]], projectRoots: [".bob"] },
+  { id: "codearts-agent", project: [".codeartsdoer", "skills"], global: [".codeartsdoer", "skills"], detect: [[".codeartsdoer"]], projectRoots: [".codeartsdoer"] },
+  { id: "codebuddy", project: [".codebuddy", "skills"], global: [".codebuddy", "skills"], detect: [[".codebuddy"]], projectRoots: [".codebuddy"] },
+  { id: "codemaker", project: [".codemaker", "skills"], global: [".codemaker", "skills"], detect: [[".codemaker"]], projectRoots: [".codemaker"] },
+  { id: "codestudio", project: [".codestudio", "skills"], global: [".codestudio", "skills"], detect: [[".codestudio"]], projectRoots: [".codestudio"] },
+  { id: "command-code", project: [".commandcode", "skills"], global: [".commandcode", "skills"], detect: [[".commandcode"]], projectRoots: [".commandcode"] },
+  { id: "cortex", project: [".cortex", "skills"], global: [".snowflake", "cortex", "skills"], detect: [[".snowflake", "cortex"]], projectRoots: [".cortex"] },
+  { id: "crush", project: [".crush", "skills"], global: [".config", "crush", "skills"], detect: [[".config", "crush"]], projectRoots: [".crush"] },
+  { id: "deepagents", project: [".agents", "skills"], global: [".deepagents", "agent", "skills"], detect: [[".deepagents"]], projectRoots: [".agents"] },
+  { id: "dexto", project: [".agents", "skills"], global: [".agents", "skills"], detect: [[".dexto"]], projectRoots: [".agents"] },
+  { id: "droid", project: [".factory", "skills"], global: [".factory", "skills"], detect: [[".factory"]], projectRoots: [".factory", ".agents"] },
+  { id: "firebender", project: [".agents", "skills"], global: [".firebender", "skills"], detect: [[".firebender"]], projectRoots: [".agents"] },
+  { id: "forgecode", project: [".forge", "skills"], global: [".forge", "skills"], detect: [[".forge"]], projectRoots: [".forge"] },
+  { id: "iflow-cli", project: [".iflow", "skills"], global: [".iflow", "skills"], detect: [[".iflow"]], projectRoots: [".iflow"] },
+  { id: "inference-sh", project: [".inferencesh", "skills"], global: [".inferencesh", "skills"], detect: [[".inferencesh"]], projectRoots: [".inferencesh"] },
+  { id: "jazz", project: [".jazz", "skills"], global: [".jazz", "skills"], detect: [[".jazz"]], projectRoots: [".jazz"] },
+  { id: "junie", project: [".junie", "skills"], global: [".junie", "skills"], detect: [[".junie"]], projectRoots: [".junie"] },
+  { id: "kimi-code-cli", project: [".agents", "skills"], global: [".agents", "skills"], detect: [[".kimi-code"], [".kimi"]], projectRoots: [".agents"] },
+  { id: "kode", project: [".kode", "skills"], global: [".kode", "skills"], detect: [[".kode"]], projectRoots: [".kode"] },
+  { id: "lingma", project: [".lingma", "skills"], global: [".lingma", "skills"], detect: [[".lingma"]], projectRoots: [".lingma"] },
+  { id: "loaf", project: [".agents", "skills"], global: [".agents", "skills"], detect: [[".loaf"]], projectRoots: [".agents"] },
+  { id: "mcpjam", project: [".mcpjam", "skills"], global: [".mcpjam", "skills"], detect: [[".mcpjam"]], projectRoots: [".mcpjam"] },
+  { id: "moxby", project: [".moxby", "skills"], global: [".moxby", "skills"], detect: [[".moxby"]], projectRoots: [".moxby"] },
+  { id: "mux", project: [".mux", "skills"], global: [".mux", "skills"], detect: [[".mux"]], projectRoots: [".mux"] },
+  { id: "neovate", project: [".neovate", "skills"], global: [".neovate", "skills"], detect: [[".neovate"]], projectRoots: [".neovate"] },
+  { id: "ona", project: [".ona", "skills"], global: [".ona", "skills"], detect: [[".ona"]], projectRoots: [".ona"] },
+  { id: "pi", project: [".pi", "skills"], global: [".pi", "agent", "skills"], detect: [[".pi", "agent"]], projectRoots: [".pi"] },
+  { id: "pochi", project: [".pochi", "skills"], global: [".pochi", "skills"], detect: [[".pochi"]], projectRoots: [".pochi"] },
+  { id: "qoder", project: [".qoder", "skills"], global: [".qoder", "skills"], detect: [[".qoder"]], projectRoots: [".qoder"] },
+  { id: "qoder-cn", project: [".qoder", "skills"], global: [".qoder-cn", "skills"], detect: [[".qoder-cn"]], projectRoots: [".qoder"] },
+  { id: "reasonix", project: [".reasonix", "skills"], global: [".reasonix", "skills"], detect: [[".reasonix"]], projectRoots: [".reasonix"] },
+  { id: "rovodev", project: [".rovodev", "skills"], global: [".rovodev", "skills"], detect: [[".rovodev"]], projectRoots: [".rovodev"] },
+  { id: "tabnine-cli", project: [".tabnine", "agent", "skills"], global: [".tabnine", "agent", "skills"], detect: [[".tabnine"]], projectRoots: [".tabnine"] },
+  { id: "terramind", project: [".terramind", "skills"], global: [".terramind", "skills"], detect: [[".terramind"]], projectRoots: [".terramind"] },
+  { id: "tinycloud", project: [".tinycloud", "skills"], global: [".tinycloud", "skills"], detect: [[".tinycloud"]], projectRoots: [".tinycloud"] },
+  { id: "trae-cn", project: [".trae", "skills"], global: [".trae-cn", "skills"], detect: [[".trae-cn"]], projectRoots: [".trae"] },
+  { id: "zcode", project: [".zcode", "skills"], global: [".zcode", "skills"], detect: [[".zcode"]], projectRoots: [".zcode"] },
+  { id: "zencoder", project: [".zencoder", "skills"], global: [".zencoder", "skills"], detect: [[".zencoder"]], projectRoots: [".zencoder"] },
+  // — project-only agents (no documented global skills dir) —
+  { id: "eve", project: ["agent", "skills"], global: null, detect: [[".eve"]], projectRoots: ["agent"] },
+  { id: "promptscript", project: [".agents", "skills"], global: null, detect: [[".promptscript"]], projectRoots: [".agents"] }
+];
+function canonicalDir(opts = {}) {
+  return opts.global ? join4(opts.home ?? homedir3(), ...CANONICAL) : join4(opts.cwd ?? process.cwd(), ...CANONICAL);
+}
+function agentById(id) {
+  const agent = AGENTS.find((a) => a.id === id);
+  if (!agent) throw new Error(`Unknown agent: ${id}. Known: ${AGENTS.map((a) => a.id).join(", ")}`);
+  return agent;
+}
+function agentSupportsGlobal(id) {
+  return agentById(id).global !== null;
+}
+function agentDir(agentId, opts = {}) {
+  const agent = agentById(agentId);
+  if (!opts.global) return join4(opts.cwd ?? process.cwd(), ...agent.project);
+  if (agent.global === null) throw new Error(`${agent.id} does not support global installs (project-only agent)`);
+  const env = opts.env ?? process.env;
+  const override = agent.globalEnv ? env[agent.globalEnv] : void 0;
+  if (override) return join4(isAbsolute(override) ? override : resolve(override), ...agent.global.slice(1));
+  return join4(opts.home ?? homedir3(), ...agent.global);
+}
+function agentRootExists(agentId, cwd) {
+  return agentById(agentId).projectRoots.some((r) => r !== CANONICAL[0] && isDir(join4(cwd, r)));
+}
+function isDir(p) {
+  try {
+    return statSync2(p).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function detectAgents(opts = {}) {
+  const home = opts.home ?? homedir3();
+  const env = opts.env ?? process.env;
+  return AGENTS.filter((a) => {
+    if (a.detect.some((d) => isDir(join4(home, ...d)))) return true;
+    const override = a.globalEnv ? env[a.globalEnv] : void 0;
+    return !!override && isDir(isAbsolute(override) ? override : resolve(override));
+  }).map((a) => a.id);
+}
+
+// src/project.ts
+import { existsSync as existsSync3 } from "fs";
+import { join as join5 } from "path";
+var PROJECT_MARKERS = [".git", "package.json", "pyproject.toml", "Cargo.toml", "go.mod", "AGENTS.md", "CLAUDE.md", "skills-lock.json"];
+var AGENT_PROJECT_ROOTS = [...new Set(AGENTS.flatMap((a) => a.projectRoots))].filter((r) => r.startsWith("."));
+function looksLikeProject(dir) {
+  if (PROJECT_MARKERS.some((m) => existsSync3(join5(dir, m)))) return true;
+  return AGENT_PROJECT_ROOTS.some((seg) => existsSync3(join5(dir, seg)));
+}
+
+// src/lock.ts
+import { existsSync as existsSync4, readFileSync as readFileSync3, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2, copyFileSync, renameSync, rmSync as rmSync2 } from "fs";
+import { homedir as homedir4 } from "os";
+import { dirname as dirname2, join as join6 } from "path";
+function lockPath(scope) {
+  return scope.global ? join6(scope.home ?? homedir4(), ".skillmd", "lock.json") : join6(scope.cwd ?? process.cwd(), "skills-lock.json");
+}
+var EMPTY = () => ({ version: 1, skills: {} });
+var corruptSeen = /* @__PURE__ */ new Set();
+function readLock(scope, opts = {}) {
+  const file = lockPath(scope);
+  if (!existsSync4(file)) return EMPTY();
+  try {
+    const parsed = JSON.parse(readFileSync3(file, "utf8"));
+    if (!parsed || typeof parsed !== "object") throw new Error("unexpected shape");
+    if (parsed.version !== 1) throw new Error(`unsupported lock version ${String(parsed.version)}`);
+    if (typeof parsed.skills !== "object" || parsed.skills === null || Array.isArray(parsed.skills)) throw new Error("unexpected shape");
+    return { version: 1, skills: parsed.skills };
+  } catch (e) {
+    corruptSeen.add(file);
+    opts.warn?.(`could not parse ${file} (${e instanceof Error ? e.message : String(e)}) \u2014 treating it as empty; a backup is written before it is next rewritten`);
+    return EMPTY();
+  }
+}
+function stripTimestamps(e) {
+  const rest = { ...e };
+  delete rest.installedAt;
+  delete rest.updatedAt;
+  return rest;
+}
+function writeLock(scope, lock) {
+  const file = lockPath(scope);
+  mkdirSync2(dirname2(file), { recursive: true });
+  if (corruptSeen.has(file) && existsSync4(file)) {
+    copyFileSync(file, `${file}.bak`);
+    corruptSeen.delete(file);
+  }
+  const names = Object.keys(lock.skills).sort();
+  const skills = {};
+  for (const n of names) skills[n] = scope.global ? lock.skills[n] : stripTimestamps(lock.skills[n]);
+  const tmp = `${file}.tmp-${process.pid}`;
+  writeFileSync2(tmp, `${JSON.stringify({ version: 1, skills }, null, 2)}
+`, "utf8");
+  try {
+    try {
+      renameSync(tmp, file);
+    } catch {
+      rmSync2(file, { force: true });
+      renameSync(tmp, file);
+    }
+  } catch (e) {
+    rmSync2(tmp, { force: true });
+    throw e;
+  }
+}
+var defaultWarnOpts = () => ({ warn: (m) => console.warn(m) });
+function upsertEntry(scope, name, entry, opts = defaultWarnOpts()) {
+  const lock = readLock(scope, opts);
+  const prev = lock.skills[name];
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  lock.skills[name] = { ...entry, installedAt: prev?.installedAt ?? entry.installedAt ?? now, updatedAt: prev ? now : entry.updatedAt ?? now };
+  writeLock(scope, lock);
+}
+function removeEntry(scope, name, opts = defaultWarnOpts()) {
+  const lock = readLock(scope, opts);
+  if (!(name in lock.skills)) return false;
+  delete lock.skills[name];
+  writeLock(scope, lock);
+  return true;
+}
+
+// src/installer.ts
+import { createHash as createHash2 } from "crypto";
+import { cpSync, existsSync as existsSync5, lstatSync as lstatSync2, mkdirSync as mkdirSync3, readdirSync as readdirSync2, renameSync as renameSync2, rmSync as rmSync3, symlinkSync, writeFileSync as writeFileSync3 } from "fs";
+import { platform } from "os";
+import { dirname as dirname3, join as join7, relative as relative2, resolve as resolve2, sep as sep2 } from "path";
+var NAME_OK = /^[a-zA-Z0-9][a-zA-Z0-9._-]*$/;
+function assertSafeName(name) {
+  if (!NAME_OK.test(name) || name.includes("..")) throw new Error(`refused unsafe skill name: "${name}"`);
+  if (WINDOWS_RESERVED.test(name)) throw new Error(`refused reserved name "${name}" (not writable on Windows)`);
+}
+function digestOf(files) {
+  const h = createHash2("sha256");
+  const norm = files.map((f) => ({ path: f.path.replace(/\\/g, "/"), contents: f.contents }));
+  norm.sort((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0);
+  for (const f of norm) {
+    h.update(f.path).update("\0").update(typeof f.contents === "string" ? Buffer.from(f.contents) : f.contents).update("\0");
+  }
+  return `sha256:${h.digest("hex")}`;
+}
+function writeTree(dest, files) {
+  if (files.length === 0) throw new Error("skill has no files");
+  mkdirSync3(dest, { recursive: true });
+  const root = resolve2(dest);
+  for (const f of files) {
+    const fp = resolve2(dest, f.path);
+    if (fp !== root && !fp.startsWith(root + sep2)) throw new Error(`refused unsafe path in skill: ${f.path}`);
+    const parts = relative2(root, fp).split(sep2);
+    if (parts.some((p) => WINDOWS_RESERVED.test(p))) throw new Error(`refused reserved file name in skill: ${f.path}`);
+    if (parts.some((p) => /[. ]$/.test(p))) throw new Error(`refused invalid file name in skill: ${f.path}`);
+    mkdirSync3(dirname3(fp), { recursive: true });
+    writeFileSync3(fp, f.contents);
+  }
+}
+function defaultLink(target, linkPath) {
+  mkdirSync3(dirname3(linkPath), { recursive: true });
+  if (platform() === "win32") {
+    symlinkSync(resolve2(target), linkPath, "junction");
+    return "junction";
+  }
+  symlinkSync(relative2(dirname3(linkPath), target) || ".", linkPath, "dir");
+  return "symlink";
+}
+function isSkillDirOrLink(p) {
+  try {
+    const st = lstatSync2(p);
+    return st.isSymbolicLink() || st.isDirectory() && existsSync5(join7(p, "SKILL.md"));
+  } catch {
+    return false;
+  }
+}
+function pathExists(p) {
+  try {
+    lstatSync2(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function removeSkillPath(p) {
+  if (!isSkillDirOrLink(p)) return false;
+  rmSync3(p, { recursive: true, force: true });
+  return true;
+}
+async function installSkill(req) {
+  assertSafeName(req.name);
+  const scope = req.scope;
+  const cwd = resolve2(scope.cwd ?? process.cwd());
+  const canonRoot = canonicalDir(scope);
+  const canonical = join7(canonRoot, req.name);
+  const lockScope = { global: Boolean(scope.global), cwd: scope.cwd, home: scope.home };
+  const lock = readLock(lockScope);
+  const prev = lock.skills[req.name];
+  let replaced;
+  if (prev && prev.source !== req.source) {
+    if (!req.force) throw new Error(`"${req.name}" is already installed from ${prev.source}; pass --force to replace it with ${req.source}`);
+    replaced = prev.source;
+  } else if (!prev && existsSync5(canonical)) {
+    if (!req.force) throw new Error(`"${req.name}" exists at ${canonical} but is not tracked by skillmd; pass --force to replace it`);
+    replaced = "untracked";
+  }
+  if (!prev) {
+    for (const agentId of req.agents) {
+      if (scope.global && !agentSupportsGlobal(agentId)) continue;
+      const dir = agentDir(agentId, scope);
+      if (resolve2(dir) === resolve2(canonRoot)) continue;
+      if (!scope.global && !req.explicitAgents && !agentRootExists(agentId, cwd)) continue;
+      const p = join7(dir, req.name);
+      if (!pathExists(p) || lstatSync2(p).isSymbolicLink()) continue;
+      if (!req.force) throw new Error(`"${req.name}" exists at ${p} but is not tracked by skillmd; pass --force to replace it`);
+      replaced = "untracked";
+    }
+  }
+  const staging = `${canonical}.tmp-${process.pid}`;
+  rmSync3(staging, { recursive: true, force: true });
+  try {
+    writeTree(staging, req.files);
+  } catch (e) {
+    rmSync3(staging, { recursive: true, force: true });
+    throw e;
+  }
+  mkdirSync3(canonRoot, { recursive: true });
+  const old = `${canonical}.old-${process.pid}`;
+  rmSync3(old, { recursive: true, force: true });
+  let movedAside = false;
+  if (pathExists(canonical)) {
+    renameSync2(canonical, old);
+    movedAside = true;
+  }
+  try {
+    renameSync2(staging, canonical);
+  } catch (e) {
+    if (movedAside && pathExists(old)) renameSync2(old, canonical);
+    rmSync3(staging, { recursive: true, force: true });
+    throw e;
+  }
+  if (movedAside) rmSync3(old, { recursive: true, force: true });
+  const link = req.link ?? defaultLink;
+  const targets = [];
+  const skipped = [];
+  const modes = {};
+  const seenDirs = /* @__PURE__ */ new Map();
+  for (const agentId of req.agents) {
+    if (scope.global && !agentSupportsGlobal(agentId)) {
+      skipped.push({ agent: agentId, reason: "project-only agent" });
+      continue;
+    }
+    const dir = agentDir(agentId, scope);
+    if (resolve2(dir) === resolve2(canonRoot)) {
+      targets.push({ agent: agentId, path: canonical, mode: "canonical" });
+      modes[agentId] = "canonical";
+      continue;
+    }
+    const first = seenDirs.get(resolve2(dir));
+    if (first) {
+      targets.push({ agent: agentId, path: first.path, mode: first.mode });
+      modes[agentId] = first.mode;
+      continue;
+    }
+    if (!scope.global && !req.explicitAgents && !agentRootExists(agentId, cwd)) {
+      const a = agentById(agentId);
+      skipped.push({ agent: agentId, reason: `not present in this project (no ${a.projectRoots[0] ?? a.project[0]}/ dir) \u2014 pass -a ${agentId} to add it` });
+      continue;
+    }
+    const linkPath = join7(dir, req.name);
+    removeSkillPath(linkPath);
+    let mode;
+    if (req.mode === "copy") {
+      mkdirSync3(dir, { recursive: true });
+      cpSync(canonical, linkPath, { recursive: true });
+      mode = "copy";
+    } else {
+      try {
+        mode = link(canonical, linkPath);
+      } catch (e) {
+        if (pathExists(linkPath)) {
+          if (!lstatSync2(linkPath).isSymbolicLink()) throw e;
+          rmSync3(linkPath, { recursive: true, force: true });
+        }
+        mkdirSync3(dir, { recursive: true });
+        cpSync(canonical, linkPath, { recursive: true });
+        mode = "copy";
+      }
+    }
+    const t = { agent: agentId, path: linkPath, mode };
+    targets.push(t);
+    seenDirs.set(resolve2(dir), t);
+    modes[agentId] = mode;
+  }
+  const digest = digestOf(req.files);
+  upsertEntry(lockScope, req.name, {
+    source: req.source,
+    commit_sha: req.commit_sha,
+    digest,
+    agents: targets.map((t) => t.agent),
+    mode: modes
+  });
+  return { canonical, targets, skipped, replaced, digest };
+}
+function uninstallSkill(name, scope) {
+  assertSafeName(name);
+  const removed = [];
+  const dirs = /* @__PURE__ */ new Set();
+  for (const a of AGENTS) {
+    if (scope.global && a.global === null) continue;
+    dirs.add(agentDir(a.id, scope));
+  }
+  for (const d of dirs) {
+    const p = join7(d, name);
+    if (removeSkillPath(p)) removed.push(p);
+  }
+  const canonical = join7(canonicalDir(scope), name);
+  if (removeSkillPath(canonical) && !removed.includes(canonical)) removed.push(canonical);
+  const hadEntry = removeEntry({ global: Boolean(scope.global), cwd: scope.cwd, home: scope.home }, name);
+  return { removed, untracked: !hadEntry };
+}
+function listInstalled(scope) {
+  const lock = readLock({ global: Boolean(scope.global), cwd: scope.cwd, home: scope.home });
+  const out = /* @__PURE__ */ new Map();
+  const kind = scope.global ? "global" : "project";
+  for (const [name, e] of Object.entries(lock.skills)) {
+    out.set(name, { name, scope: kind, path: join7(canonicalDir(scope), name), agents: [...e.agents], source: e.source, mode: e.mode, tracked: true });
+  }
+  const seen = /* @__PURE__ */ new Set();
+  for (const a of AGENTS) {
+    if (scope.global && a.global === null) continue;
+    const dir = agentDir(a.id, scope);
+    if (seen.has(dir) || !existsSync5(dir)) continue;
+    seen.add(dir);
+    for (const entry of readdirSync2(dir)) {
+      const p = join7(dir, entry);
+      if (!existsSync5(join7(p, "SKILL.md"))) continue;
+      const known = out.get(entry);
+      if (known) {
+        if (!known.agents.includes(a.id) && lstatSync2(p).isSymbolicLink()) known.agents.push(a.id);
+        continue;
+      }
+      out.set(entry, { name: entry, scope: kind, path: p, agents: [a.id], mode: { [a.id]: "copy" }, tracked: false });
+    }
+  }
+  return [...out.values()].sort((x, y) => x.name.localeCompare(y.name));
+}
+
+export {
+  parseSource,
+  gigetInput,
+  sourceId,
+  configPath,
+  readConfig,
+  writeConfig,
+  hostOf,
+  resolveApi,
+  telemetryDisabled,
+  IntegrityError,
+  RegistryError,
+  createClient,
+  fetchBundle,
+  skillMdFor,
+  resolveSource,
+  collectFiles,
+  resolveTree,
+  resolvePackFiles,
+  stripTerminalEscapes,
+  safeText,
+  AGENTS,
+  canonicalDir,
+  agentSupportsGlobal,
+  agentDir,
+  detectAgents,
+  looksLikeProject,
+  readLock,
+  upsertEntry,
+  digestOf,
+  isSkillDirOrLink,
+  installSkill,
+  uninstallSkill,
+  listInstalled
+};