skills-master 0.1.0

package/dist/bin.js

@@ -0,0 +1,1604 @@
+#!/usr/bin/env node
+
+// src/bin.ts
+import { Command } from "commander";
+
+// src/types.ts
+var ALL_TARGETS = ["claude", "cursor", "copilot", "agents"];
+var RESOURCE_FILES = {
+  reference: "reference.md",
+  examples: "examples.md",
+  checklist: "checklist.md"
+};
+
+// src/schema/projectConfig.ts
+import { z } from "zod";
+var TargetIdSchema = z.enum(["claude", "cursor", "copilot", "agents"]);
+var DEFAULT_PATHS = {
+  claude: ".claude/skills",
+  cursor: ".cursor/rules",
+  copilot: ".github",
+  agents: "AGENTS.md"
+};
+var ProjectConfigSchema = z.object({
+  $schema: z.string().optional(),
+  /** Git ref of the content repo to install from (tag/branch/sha). */
+  contentRef: z.string().default("main"),
+  /**
+   * Targets to emit. Empty array means "auto-detect on every run".
+   */
+  targets: z.array(TargetIdSchema).default([]),
+  /** Per-target output path overrides (merged over DEFAULT_PATHS). */
+  paths: z.object({
+    claude: z.string(),
+    cursor: z.string(),
+    copilot: z.string(),
+    agents: z.string()
+  }).partial().default({}),
+  scope: z.enum(["project"]).default("project"),
+  /** true = commit generated files; false = add them to .gitignore. */
+  commit: z.boolean().default(true)
+}).strict();
+var CONFIG_FILENAME = "skills-master.json";
+var LOCKFILE_NAME = "skills-master.lock.json";
+function resolvePaths(cfg) {
+  return { ...DEFAULT_PATHS, ...cfg.paths };
+}
+
+// src/core/yaml.ts
+import YAML from "yaml";
+function toYaml(obj) {
+  return YAML.stringify(obj, { lineWidth: 0 }).trimEnd();
+}
+function frontmatterBlock(obj) {
+  return `---
+${toYaml(obj)}
+---`;
+}
+function withFrontmatter(obj, body) {
+  return `${frontmatterBlock(obj)}
+
+${body.trim()}
+`;
+}
+
+// src/emitters/util.ts
+import { existsSync } from "fs";
+import { join } from "path";
+function existsRel(root, rel) {
+  return existsSync(join(root, rel));
+}
+var ACRONYMS = {
+  hig: "HIG",
+  ui: "UI",
+  ml: "ML",
+  ar: "AR",
+  av: "AV",
+  os: "OS",
+  ci: "CI",
+  cd: "CD",
+  url: "URL",
+  api: "API",
+  sf: "SF",
+  spm: "SPM",
+  ios: "iOS",
+  ipados: "iPadOS",
+  macos: "macOS",
+  tvos: "tvOS",
+  visionos: "visionOS",
+  watchos: "watchOS"
+};
+function titleFromName(name) {
+  return name.split("-").filter(Boolean).map((w) => ACRONYMS[w] ?? w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
+}
+function globsToString(fm) {
+  const g = fm.globs;
+  if (!g || g.length === 0) return void 0;
+  return g.join(",");
+}
+function hasResources(resources) {
+  return Boolean(resources.reference || resources.examples || resources.checklist);
+}
+
+// src/emitters/claude.ts
+var claudeEmitter = {
+  id: "claude",
+  label: "Claude Code",
+  detect: (root) => existsRel(root, ".claude"),
+  emit(skill, ctx) {
+    const dir = `${ctx.paths.claude}/${skill.name}`;
+    const fm = {
+      name: skill.frontmatter.name,
+      description: skill.frontmatter.description
+    };
+    const files = [
+      {
+        path: `${dir}/SKILL.md`,
+        contents: withFrontmatter(fm, skill.body),
+        mode: "whole"
+      }
+    ];
+    for (const key of Object.keys(RESOURCE_FILES)) {
+      const text = skill.resources[key];
+      if (text) {
+        files.push({
+          path: `${dir}/${RESOURCE_FILES[key]}`,
+          contents: text.trimEnd() + "\n",
+          mode: "whole"
+        });
+      }
+    }
+    return files;
+  }
+};
+
+// src/core/condense.ts
+var L3_LINK_RE = /\[([^\]]+)\]\((?:\.\/)?(reference|examples|checklist)\.md(?:#[^)]*)?\)/g;
+var DEFAULT_NOTE = "Extended reference and worked examples are available in the full Claude Code skill for this topic.";
+function condenseBody(body, opts = {}) {
+  let out = body;
+  let strippedLink = false;
+  out = out.replace(L3_LINK_RE, (_m, text) => {
+    strippedLink = true;
+    return text;
+  });
+  if (opts.openQuestion === "summarize") {
+    out = summarizeOpenQuestion(out);
+  }
+  out = out.replace(/\n{3,}/g, "\n\n").trim();
+  if (opts.hadResources || strippedLink) {
+    out += `
+
+> ${opts.fullSkillNote ?? DEFAULT_NOTE}`;
+  }
+  return out + "\n";
+}
+function summarizeOpenQuestion(body) {
+  const re = /^## Open question[ \t]*\n([\s\S]*?)(?=\n## |\s*$)/m;
+  return body.replace(re, (_m, section) => {
+    const firstPara = section.trim().split(/\n\s*\n/)[0]?.replace(/\s+/g, " ").trim() ?? "";
+    return `## Open question
+
+Tradeoff: ${firstPara}
+`;
+  });
+}
+
+// src/emitters/cursor.ts
+var cursorEmitter = {
+  id: "cursor",
+  label: "Cursor",
+  detect: (root) => existsRel(root, ".cursor"),
+  emit(skill, ctx) {
+    const globs = globsToString(skill.frontmatter);
+    const fm = {
+      description: skill.frontmatter.description
+    };
+    if (globs) fm.globs = globs;
+    fm.alwaysApply = false;
+    const body = condenseBody(skill.body, {
+      openQuestion: "keep",
+      hadResources: hasResources(skill.resources)
+    });
+    return [
+      {
+        path: `${ctx.paths.cursor}/${skill.name}.mdc`,
+        contents: withFrontmatter(fm, body),
+        mode: "whole"
+      }
+    ];
+  }
+};
+
+// src/emitters/copilot.ts
+var copilotEmitter = {
+  id: "copilot",
+  label: "GitHub Copilot",
+  detect: (root) => existsRel(root, ".github"),
+  emit(skill, ctx) {
+    const base = ctx.paths.copilot;
+    const instructionsPath = `${base}/instructions/${skill.name}.instructions.md`;
+    const applyTo = globsToString(skill.frontmatter) ?? "**";
+    const fm = {
+      applyTo,
+      description: skill.frontmatter.description
+    };
+    const body = condenseBody(skill.body, {
+      openQuestion: "keep",
+      hadResources: hasResources(skill.resources)
+    });
+    const pointer = `For ${titleFromName(skill.name)} guidance, see \`${instructionsPath}\`.`;
+    return [
+      {
+        path: instructionsPath,
+        contents: withFrontmatter(fm, body),
+        mode: "whole"
+      },
+      {
+        path: `${base}/copilot-instructions.md`,
+        contents: pointer,
+        mode: "block",
+        blockId: skill.name,
+        blockVersion: skill.frontmatter["x-skills-master"].version
+      }
+    ];
+  }
+};
+
+// src/emitters/agents.ts
+var agentsEmitter = {
+  id: "agents",
+  label: "AGENTS.md",
+  detect: (root) => existsRel(root, "AGENTS.md"),
+  emit(skill, ctx) {
+    const body = condenseBody(skill.body, {
+      openQuestion: "summarize",
+      hadResources: hasResources(skill.resources)
+    });
+    const section = `### ${titleFromName(skill.name)}
+
+${body.trim()}`;
+    return [
+      {
+        path: ctx.paths.agents,
+        contents: section,
+        mode: "block",
+        blockId: skill.name,
+        blockVersion: skill.frontmatter["x-skills-master"].version
+      }
+    ];
+  }
+};
+
+// src/emitters/index.ts
+var EMITTERS = [
+  claudeEmitter,
+  cursorEmitter,
+  copilotEmitter,
+  agentsEmitter
+];
+var BY_ID = new Map(EMITTERS.map((e) => [e.id, e]));
+function getEmitter(id) {
+  return BY_ID.get(id);
+}
+function detectTargets(projectRoot) {
+  return EMITTERS.filter((e) => e.detect(projectRoot)).map((e) => e.id);
+}
+
+// src/core/project.ts
+import { existsSync as existsSync2, readFileSync, writeFileSync } from "fs";
+import { join as join2 } from "path";
+
+// src/schema/lockfile.ts
+import { z as z2 } from "zod";
+var EmittedTargetSchema = z2.object({
+  /** whole-file outputs owned by this target for this skill. */
+  files: z2.array(z2.string()).default([]),
+  /** shared file this skill writes a managed block into (block-mode targets). */
+  block: z2.string().optional(),
+  /** sha256 of the concatenated emitted contents, for drift detection. */
+  hash: z2.string()
+});
+var LockedSkillSchema = z2.object({
+  /** resolved skill version at install time. */
+  version: z2.string(),
+  /** sha256 of the canonical SKILL.md + resource files at install time. */
+  sourceHash: z2.string(),
+  /** targets this skill was emitted to. */
+  emitted: z2.record(z2.string(), EmittedTargetSchema)
+});
+var LockfileSchema = z2.object({
+  lockfileVersion: z2.literal(1).default(1),
+  contentRef: z2.string().default("main"),
+  skills: z2.record(z2.string(), LockedSkillSchema).default({})
+});
+function emptyLockfile(contentRef = "main") {
+  return { lockfileVersion: 1, contentRef, skills: {} };
+}
+
+// src/core/project.ts
+function configPath(root) {
+  return join2(root, CONFIG_FILENAME);
+}
+function lockfilePath(root) {
+  return join2(root, LOCKFILE_NAME);
+}
+function loadConfig(root) {
+  const p = configPath(root);
+  if (!existsSync2(p)) return null;
+  return ProjectConfigSchema.parse(JSON.parse(readFileSync(p, "utf8")));
+}
+function loadConfigOrDefault(root) {
+  return loadConfig(root) ?? ProjectConfigSchema.parse({});
+}
+function saveConfig(root, cfg) {
+  const withSchema = { $schema: "https://skills-master.dev/schema/config.json", ...cfg };
+  writeFileSync(configPath(root), JSON.stringify(withSchema, null, 2) + "\n", "utf8");
+}
+function loadLockfile(root) {
+  const p = lockfilePath(root);
+  if (!existsSync2(p)) return emptyLockfile();
+  return LockfileSchema.parse(JSON.parse(readFileSync(p, "utf8")));
+}
+function saveLockfile(root, lock) {
+  writeFileSync(lockfilePath(root), JSON.stringify(lock, null, 2) + "\n", "utf8");
+}
+
+// src/util/log.ts
+var quiet = false;
+var sym = {
+  info: "\u2022",
+  ok: "\u2713",
+  warn: "!",
+  err: "\u2717"
+};
+var log = {
+  plain(msg) {
+    if (!quiet) console.log(msg);
+  },
+  info(msg) {
+    if (!quiet) console.log(`${sym.info} ${msg}`);
+  },
+  success(msg) {
+    if (!quiet) console.log(`${sym.ok} ${msg}`);
+  },
+  warn(msg) {
+    if (!quiet) console.warn(`${sym.warn} ${msg}`);
+  },
+  error(msg) {
+    console.error(`${sym.err} ${msg}`);
+  }
+};
+
+// src/commands/init.ts
+function initCommand(opts) {
+  const existing = loadConfig(opts.cwd);
+  if (existing && !opts.force) {
+    log.warn(`skills-master.json already exists \u2014 leaving it untouched (use --force to overwrite).`);
+    return existing;
+  }
+  let targets = opts.targets;
+  if (!targets || targets.length === 0) {
+    const detected = detectTargets(opts.cwd);
+    if (detected.length > 0) {
+      targets = detected;
+      log.info(`Detected tools: ${detected.join(", ")}`);
+    } else {
+      targets = ALL_TARGETS;
+      log.info(`No tools detected \u2014 defaulting to all targets (${ALL_TARGETS.join(", ")}).`);
+    }
+  }
+  const cfg = ProjectConfigSchema.parse({
+    contentRef: opts.contentRef ?? "main",
+    targets,
+    commit: opts.commit ?? true
+  });
+  saveConfig(opts.cwd, cfg);
+  log.success(`Wrote skills-master.json (targets: ${targets.join(", ")}, commit: ${cfg.commit}).`);
+  return cfg;
+}
+
+// src/content/source.ts
+import { existsSync as existsSync5 } from "fs";
+import { homedir } from "os";
+import { basename as basename2, isAbsolute, join as join5, resolve } from "path";
+
+// src/core/discover.ts
+import { existsSync as existsSync3, readdirSync, statSync } from "fs";
+import { join as join3, relative } from "path";
+var SKILL_FILE = "SKILL.md";
+var IGNORE = /* @__PURE__ */ new Set(["node_modules", ".git", "dist", ".cache"]);
+function findSkillDirs(skillsRoot) {
+  const found = [];
+  if (!existsSync3(skillsRoot)) return found;
+  const walk = (dir) => {
+    let entries;
+    try {
+      entries = readdirSync(dir);
+    } catch {
+      return;
+    }
+    if (entries.includes(SKILL_FILE)) found.push(dir);
+    for (const entry of entries) {
+      if (IGNORE.has(entry) || entry.startsWith(".")) continue;
+      const full = join3(dir, entry);
+      let isDir = false;
+      try {
+        isDir = statSync(full).isDirectory();
+      } catch {
+        isDir = false;
+      }
+      if (isDir) walk(full);
+    }
+  };
+  walk(skillsRoot);
+  return found.sort();
+}
+function relPathOf(skillsRoot, dir) {
+  return relative(skillsRoot, dir).split(/[\\/]/).join("/");
+}
+
+// src/core/parse.ts
+import { existsSync as existsSync4, readFileSync as readFileSync2 } from "fs";
+import { basename, join as join4 } from "path";
+import matter from "gray-matter";
+
+// src/schema/frontmatter.ts
+import { z as z3 } from "zod";
+import semver from "semver";
+var NAME_RE = /^[a-z0-9-]{1,64}$/;
+var ISO_DATE_RE = /^\d{4}-\d{2}-\d{2}$/;
+var StabilitySchema = z3.enum(["stable", "emerging", "contested"]);
+var SkillClassSchema = z3.enum([
+  "code",
+  "design",
+  "lang-tooling",
+  "overview"
+]);
+var CLASS_DIR = {
+  code: "code",
+  design: "design",
+  "lang-tooling": "lang-tooling",
+  overview: "overviews"
+};
+var XSkillsMasterSchema = z3.object({
+  domain: z3.string().min(1),
+  class: SkillClassSchema,
+  category: z3.string().min(1),
+  platforms: z3.array(z3.string().min(1)).min(1),
+  /** domain-defined version requirements, e.g. { ios: "17", swift: "6.0" }. */
+  requires: z3.record(z3.string(), z3.string()).optional(),
+  pairs_with: z3.array(z3.string().regex(NAME_RE)).default([]),
+  /** citation URLs to canonical docs — never verbatim content. */
+  sources: z3.array(z3.string().url()).default([]),
+  snapshot_date: z3.string().regex(ISO_DATE_RE, "must be an ISO date (YYYY-MM-DD)"),
+  stability: StabilitySchema,
+  version: z3.string().refine((v) => semver.valid(v) != null, "must be a valid semver version")
+}).strict();
+var GlobsSchema = z3.union([z3.string(), z3.array(z3.string())]).transform((g) => Array.isArray(g) ? g : [g]).optional();
+var FrontmatterSchema = z3.object({
+  name: z3.string().regex(NAME_RE, "must be kebab-case ([a-z0-9-], <=64 chars)"),
+  description: z3.string().min(1, "description is required").max(1024, "description must be <= 1024 characters"),
+  globs: GlobsSchema,
+  tags: z3.array(z3.string()).default([]),
+  "x-skills-master": XSkillsMasterSchema
+}).passthrough();
+
+// src/core/parse.ts
+function loadRawSkill(dir, skillsRoot) {
+  const skillMdPath = join4(dir, "SKILL.md");
+  const rawText = readFileSync2(skillMdPath, "utf8");
+  const parsed = matter(rawText);
+  const resources = {};
+  for (const key of Object.keys(RESOURCE_FILES)) {
+    const p = join4(dir, RESOURCE_FILES[key]);
+    if (existsSync4(p)) resources[key] = readFileSync2(p, "utf8");
+  }
+  return {
+    dir,
+    relPath: relPathOf(skillsRoot, dir),
+    folderName: basename(dir),
+    data: parsed.data,
+    body: parsed.content.replace(/^\n+/, "").trimEnd(),
+    resources,
+    skillMdPath,
+    rawText
+  };
+}
+var SkillValidationError = class extends Error {
+  constructor(relPath, issues) {
+    super(`Invalid skill "${relPath}":
+  - ${issues.join("\n  - ")}`);
+    this.relPath = relPath;
+    this.issues = issues;
+    this.name = "SkillValidationError";
+  }
+  relPath;
+  issues;
+};
+function validateFrontmatter(data) {
+  const result = FrontmatterSchema.safeParse(data);
+  if (result.success) return { ok: true, value: result.data };
+  const issues = result.error.issues.map((i) => {
+    const path = i.path.join(".");
+    return path ? `${path}: ${i.message}` : i.message;
+  });
+  return { ok: false, issues };
+}
+function loadSkill(dir, skillsRoot) {
+  const raw = loadRawSkill(dir, skillsRoot);
+  const validated = validateFrontmatter(raw.data);
+  if (!validated.ok) throw new SkillValidationError(raw.relPath, validated.issues);
+  return {
+    name: validated.value.name,
+    dir: raw.dir,
+    relPath: raw.relPath,
+    frontmatter: validated.value,
+    body: raw.body,
+    resources: raw.resources
+  };
+}
+
+// src/core/registry-build.ts
+function buildRegistry(skillsRoot, version = "0.1.0") {
+  const dirs = findSkillDirs(skillsRoot);
+  const skills = dirs.map((dir) => {
+    const s = loadSkill(dir, skillsRoot);
+    const xm = s.frontmatter["x-skills-master"];
+    return {
+      name: s.name,
+      domain: xm.domain,
+      class: xm.class,
+      category: xm.category,
+      description: s.frontmatter.description,
+      platforms: xm.platforms,
+      stability: xm.stability,
+      version: xm.version,
+      tags: s.frontmatter.tags ?? [],
+      pairs_with: xm.pairs_with,
+      path: s.relPath,
+      resources: {
+        reference: Boolean(s.resources.reference),
+        examples: Boolean(s.resources.examples),
+        checklist: Boolean(s.resources.checklist)
+      }
+    };
+  });
+  skills.sort((a, b) => a.name.localeCompare(b.name));
+  return {
+    $schema: "https://skills-master.dev/schema/registry.json",
+    version,
+    skills
+  };
+}
+
+// src/content/source.ts
+var DEFAULT_REPO = "github:iChintanSoni/skills-master";
+var ContentSource = class {
+  constructor(root) {
+    this.root = root;
+  }
+  root;
+  skillDirs() {
+    return findSkillDirs(this.root);
+  }
+  findDir(name) {
+    const dirs = this.skillDirs();
+    return dirs.find((d) => basename2(d) === name) ?? dirs.find((d) => safeName(d, this.root) === name);
+  }
+  loadSkill(name) {
+    const dir = this.findDir(name);
+    if (!dir) throw new Error(`Skill "${name}" not found in content at ${this.root}`);
+    return loadSkill(dir, this.root);
+  }
+  registry() {
+    return buildRegistry(this.root);
+  }
+};
+function safeName(dir, root) {
+  try {
+    return loadSkill(dir, root).name;
+  } catch {
+    return "";
+  }
+}
+async function resolveContent(opts = {}) {
+  if (opts.content) {
+    const root = isAbsolute(opts.content) ? opts.content : resolve(process.cwd(), opts.content);
+    return new ContentSource(root);
+  }
+  const env = process.env.SKILLS_MASTER_CONTENT;
+  if (env) return new ContentSource(resolve(env));
+  const local = findLocalSkillsDir(opts.cwd ?? process.cwd());
+  if (local) return new ContentSource(local);
+  return new ContentSource(await fetchRemote(opts.ref ?? "main"));
+}
+function findLocalSkillsDir(start) {
+  let dir = resolve(start);
+  for (let i = 0; i < 8; i++) {
+    const candidate = join5(dir, "skills");
+    if (existsSync5(join5(dir, "pnpm-workspace.yaml")) && existsSync5(candidate)) return candidate;
+    const parent = resolve(dir, "..");
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return null;
+}
+async function fetchRemote(ref) {
+  const repo = process.env.SKILLS_MASTER_REPO ?? DEFAULT_REPO;
+  const cacheDir = join5(homedir(), ".skills-master-cache", ref.replace(/[^\w.-]/g, "_"));
+  const { downloadTemplate } = await import("giget");
+  const { dir } = await downloadTemplate(`${repo}/skills#${ref}`, {
+    dir: cacheDir,
+    force: true,
+    forceClean: true
+  });
+  return dir;
+}
+
+// src/core/install.ts
+import { existsSync as existsSync7, readFileSync as readFileSync4 } from "fs";
+import { join as join7 } from "path";
+
+// src/core/compile.ts
+function compileSkill(skill, targets, ctx) {
+  const out = [];
+  for (const target of targets) {
+    const emitter = getEmitter(target);
+    if (!emitter) throw new Error(`Unknown target: ${target}`);
+    out.push({ target, files: emitter.emit(skill, ctx) });
+  }
+  return out;
+}
+
+// src/core/writer.ts
+import { existsSync as existsSync6, mkdirSync, readdirSync as readdirSync2, readFileSync as readFileSync3, rmdirSync, rmSync, writeFileSync as writeFileSync2 } from "fs";
+import { dirname, join as join6 } from "path";
+
+// src/core/markers.ts
+var PREFIX = "skills-master";
+function escapeRe(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function beginMarker(id, version) {
+  return version ? `<!-- BEGIN ${PREFIX}:${id} v${version} -->` : `<!-- BEGIN ${PREFIX}:${id} -->`;
+}
+function endMarker(id) {
+  return `<!-- END ${PREFIX}:${id} -->`;
+}
+function blockRegex(id) {
+  const esc = escapeRe(id);
+  return new RegExp(
+    `[ \\t]*<!-- BEGIN ${PREFIX}:${esc}(?: v[^>]*)? -->[\\s\\S]*?<!-- END ${PREFIX}:${esc} -->`
+  );
+}
+function renderBlock(id, body, version) {
+  return `${beginMarker(id, version)}
+${body.trim()}
+${endMarker(id)}`;
+}
+function hasBlock(file, id) {
+  return blockRegex(id).test(file);
+}
+function upsertBlock(file, id, body, version) {
+  const block = renderBlock(id, body, version);
+  const re = blockRegex(id);
+  if (re.test(file)) {
+    return file.replace(re, block);
+  }
+  const base = file.replace(/\s+$/, "");
+  if (base.length === 0) return block + "\n";
+  return `${base}
+
+${block}
+`;
+}
+function removeBlock(file, id) {
+  const re = new RegExp(blockRegex(id).source + `\\n?\\n?`);
+  const next = file.replace(re, "");
+  return next.trim().length === 0 ? "" : next.replace(/\n{3,}/g, "\n\n").trimEnd() + "\n";
+}
+
+// src/core/writer.ts
+function ensureDir(absPath) {
+  mkdirSync(dirname(absPath), { recursive: true });
+}
+function applyWhole(projectRoot, file, opts) {
+  const abs = join6(projectRoot, file.path);
+  const exists = existsSync6(abs);
+  const next = file.contents;
+  if (!exists) {
+    if (!opts.dryRun) {
+      ensureDir(abs);
+      writeFileSync2(abs, next, "utf8");
+    }
+    return { path: file.path, mode: "whole", action: "created", after: next };
+  }
+  const current = readFileSync3(abs, "utf8");
+  if (current === next) {
+    return { path: file.path, mode: "whole", action: "unchanged" };
+  }
+  let choice = "overwrite";
+  if (!opts.overwrite) {
+    choice = opts.onConflict ? opts.onConflict(file.path) : opts.dryRun ? "overwrite" : "skip";
+  }
+  if (choice === "skip") {
+    return { path: file.path, mode: "whole", action: "skipped", before: current, after: next };
+  }
+  if (!opts.dryRun) writeFileSync2(abs, next, "utf8");
+  return { path: file.path, mode: "whole", action: "updated", before: current, after: next };
+}
+function applyBlock(projectRoot, file, opts) {
+  const abs = join6(projectRoot, file.path);
+  const exists = existsSync6(abs);
+  const current = exists ? readFileSync3(abs, "utf8") : "";
+  const blockId = file.blockId;
+  const next = upsertBlock(current, blockId, file.contents, file.blockVersion);
+  let action;
+  if (current === next) action = "unchanged";
+  else if (!exists || !hasBlock(current, blockId)) action = "created";
+  else action = "updated";
+  if (action !== "unchanged" && !opts.dryRun) {
+    ensureDir(abs);
+    writeFileSync2(abs, next, "utf8");
+  }
+  return { path: file.path, mode: "block", blockId, action };
+}
+function applyFiles(projectRoot, files, opts = {}) {
+  return files.map(
+    (f) => f.mode === "block" ? applyBlock(projectRoot, f, opts) : applyWhole(projectRoot, f, opts)
+  );
+}
+function pruneEmptyDirs(projectRoot, relFilePaths, dryRun = false) {
+  if (dryRun) return;
+  const seen = /* @__PURE__ */ new Set();
+  for (const rel of relFilePaths) {
+    let dir = dirname(join6(projectRoot, rel));
+    while (dir.startsWith(projectRoot) && dir !== projectRoot && !seen.has(dir)) {
+      seen.add(dir);
+      try {
+        if (existsSync6(dir) && readdirSync2(dir).length === 0) {
+          rmdirSync(dir);
+          dir = dirname(dir);
+        } else break;
+      } catch {
+        break;
+      }
+    }
+  }
+}
+function removeWholeFile(projectRoot, relPath, dryRun = false) {
+  const abs = join6(projectRoot, relPath);
+  if (!existsSync6(abs)) return false;
+  if (!dryRun) rmSync(abs);
+  return true;
+}
+function removeBlockFromFile(projectRoot, relPath, blockId, dryRun = false) {
+  const abs = join6(projectRoot, relPath);
+  if (!existsSync6(abs)) return false;
+  const current = readFileSync3(abs, "utf8");
+  if (!hasBlock(current, blockId)) return false;
+  const next = removeBlock(current, blockId);
+  if (!dryRun) {
+    if (next.trim().length === 0) rmSync(abs);
+    else writeFileSync2(abs, next, "utf8");
+  }
+  return true;
+}
+
+// src/core/hash.ts
+import { createHash } from "crypto";
+function sha256(...parts) {
+  const h = createHash("sha256");
+  for (const p of parts) {
+    h.update(p, "utf8");
+    h.update("\0");
+  }
+  return "sha256:" + h.digest("hex");
+}
+
+// src/core/install.ts
+function sourceHashOf(skill) {
+  const xm = skill.frontmatter["x-skills-master"];
+  return sha256(
+    skill.relPath,
+    xm.version,
+    skill.frontmatter.description,
+    skill.body,
+    skill.resources.reference ?? "",
+    skill.resources.examples ?? "",
+    skill.resources.checklist ?? ""
+  );
+}
+function diskHash(projectRoot, relPaths) {
+  const sorted = [...relPaths].sort((a, b) => a.localeCompare(b));
+  const parts = [];
+  for (const p of sorted) {
+    const abs = join7(projectRoot, p);
+    const contents = existsSync7(abs) ? readFileSync4(abs, "utf8") : "<<missing>>";
+    parts.push(p, contents);
+  }
+  return sha256(...parts);
+}
+function installSkill(projectRoot, skill, targets, paths, opts = {}) {
+  const compiled = compileSkill(skill, targets, { projectRoot, paths });
+  const allFiles = compiled.flatMap((c) => c.files);
+  const results = applyFiles(projectRoot, allFiles, opts);
+  const emitted = {};
+  for (const c of compiled) {
+    const whole = c.files.filter((f) => f.mode === "whole").map((f) => f.path);
+    const block = c.files.find((f) => f.mode === "block")?.path;
+    const hash = opts.dryRun ? sha256("dry-run", ...whole) : diskHash(projectRoot, whole);
+    emitted[c.target] = { files: whole, ...block ? { block } : {}, hash };
+  }
+  const version = skill.frontmatter["x-skills-master"].version;
+  return {
+    name: skill.name,
+    version,
+    results,
+    locked: { version, sourceHash: sourceHashOf(skill), emitted }
+  };
+}
+
+// src/core/gitignore.ts
+import { existsSync as existsSync8, readFileSync as readFileSync5, writeFileSync as writeFileSync3 } from "fs";
+import { join as join8 } from "path";
+function ensureGitignored(root, entries) {
+  const p = join8(root, ".gitignore");
+  const current = existsSync8(p) ? readFileSync5(p, "utf8") : "";
+  const lines = new Set(current.split("\n").map((l) => l.trim()));
+  const missing = entries.filter((e) => !lines.has(e));
+  if (missing.length === 0) return;
+  const header = current.includes("# skills-master") ? "" : "\n# skills-master generated outputs\n";
+  const next = current.replace(/\s*$/, "") + header + missing.join("\n") + "\n";
+  writeFileSync3(p, next, "utf8");
+}
+
+// src/commands/add.ts
+async function addCommand(opts) {
+  const cfg = loadConfigOrDefault(opts.cwd);
+  const hadConfig = loadConfig(opts.cwd) != null;
+  let targets = opts.targets?.length ? opts.targets : cfg.targets;
+  if (!targets.length) targets = detectTargets(opts.cwd);
+  if (!targets.length) targets = ALL_TARGETS;
+  const content = await resolveContent({
+    content: opts.content,
+    ref: opts.ref ?? cfg.contentRef,
+    cwd: opts.cwd
+  });
+  const registry2 = content.registry();
+  const byName = new Map(registry2.skills.map((s) => [s.name, s]));
+  const selected = /* @__PURE__ */ new Set();
+  const skipped = [];
+  for (const token of opts.names) {
+    if (byName.has(token)) {
+      selected.add(token);
+      continue;
+    }
+    const byCategory = registry2.skills.filter((s) => s.category === token);
+    const byClass = registry2.skills.filter((s) => s.class === token);
+    const group = byCategory.length ? byCategory : byClass;
+    if (group.length) {
+      group.forEach((s) => selected.add(s.name));
+    } else {
+      log.warn(`No skill, category, or class matches "${token}".`);
+      skipped.push(token);
+    }
+  }
+  if (opts.withPairs) {
+    for (const name of [...selected]) {
+      for (const pair of byName.get(name)?.pairs_with ?? []) {
+        if (byName.has(pair)) selected.add(pair);
+        else log.warn(`Paired skill "${pair}" (from "${name}") is not in the registry.`);
+      }
+    }
+  }
+  if (selected.size === 0) {
+    log.error("Nothing to install.");
+    return { targets, installed: [], skipped };
+  }
+  const paths = resolvePaths(cfg);
+  const lock = loadLockfile(opts.cwd);
+  lock.contentRef = opts.ref ?? cfg.contentRef;
+  const installed = [];
+  const prefix = opts.dryRun ? "[dry-run] " : "";
+  for (const name of [...selected].sort()) {
+    const skill = content.loadSkill(name);
+    const result = installSkill(opts.cwd, skill, targets, paths, {
+      dryRun: opts.dryRun,
+      overwrite: opts.overwrite,
+      onConflict: opts.onConflict
+    });
+    if (!opts.dryRun) lock.skills[name] = result.locked;
+    installed.push({ name, version: result.version });
+    for (const r of result.results) {
+      const tag = r.mode === "block" ? `${r.path} [${r.blockId}]` : r.path;
+      log.info(`${prefix}${r.action.padEnd(9)} ${tag}`);
+    }
+  }
+  if (!opts.dryRun) {
+    saveLockfile(opts.cwd, lock);
+    if (!hadConfig) {
+      saveConfig(opts.cwd, { ...cfg, targets });
+      log.info("Wrote skills-master.json.");
+    }
+    if (!cfg.commit) {
+      const outs = targets.map((t) => paths[t]);
+      ensureGitignored(opts.cwd, outs);
+    }
+  }
+  log.success(
+    `${prefix}Installed ${installed.length} skill(s) into ${targets.length} target(s): ${targets.join(", ")}.`
+  );
+  return { targets, installed, skipped };
+}
+
+// src/commands/update.ts
+async function updateCommand(opts) {
+  const cfg = loadConfigOrDefault(opts.cwd);
+  const lock = loadLockfile(opts.cwd);
+  const ref = opts.ref ?? cfg.contentRef;
+  const updated = [];
+  const upToDate = [];
+  const skipped = [];
+  const names = opts.names?.length ? opts.names : Object.keys(lock.skills);
+  if (names.length === 0) {
+    log.info("No installed skills to update.");
+    return { updated, upToDate, skipped };
+  }
+  const content = await resolveContent({ content: opts.content, ref, cwd: opts.cwd });
+  const paths = resolvePaths(cfg);
+  const prefix = opts.dryRun ? "[dry-run] " : "";
+  for (const name of names.sort()) {
+    const locked = lock.skills[name];
+    if (!locked) {
+      log.warn(`"${name}" is not installed \u2014 run \`add\` first.`);
+      skipped.push(name);
+      continue;
+    }
+    let skill;
+    try {
+      skill = content.loadSkill(name);
+    } catch {
+      log.warn(`"${name}" no longer exists in the content library.`);
+      skipped.push(name);
+      continue;
+    }
+    const refChanged = lock.contentRef !== ref;
+    const sourceChanged = locked.sourceHash !== sourceHashOf(skill);
+    if (!opts.overwrite && !sourceChanged && !refChanged) {
+      upToDate.push(name);
+      continue;
+    }
+    const targets = Object.keys(locked.emitted);
+    const userEdited = targets.some((t) => {
+      const e = locked.emitted[t];
+      return e && diskHash(opts.cwd, e.files) !== e.hash;
+    });
+    if (userEdited && !opts.overwrite && !opts.onConflict) {
+      log.warn(`${prefix}"${name}" has local edits \u2014 skipping (use --overwrite to replace).`);
+      skipped.push(name);
+      continue;
+    }
+    const result = installSkill(opts.cwd, skill, targets, paths, {
+      dryRun: opts.dryRun,
+      overwrite: opts.overwrite || !userEdited,
+      onConflict: opts.onConflict
+    });
+    if (!opts.dryRun) lock.skills[name] = result.locked;
+    updated.push(name);
+    for (const r of result.results) {
+      if (r.action === "unchanged") continue;
+      const tag = r.mode === "block" ? `${r.path} [${r.blockId}]` : r.path;
+      log.info(`${prefix}${r.action.padEnd(9)} ${tag}`);
+    }
+  }
+  if (!opts.dryRun) {
+    lock.contentRef = ref;
+    saveLockfile(opts.cwd, lock);
+  }
+  log.success(
+    `${prefix}Updated ${updated.length}, up-to-date ${upToDate.length}, skipped ${skipped.length}.`
+  );
+  return { updated, upToDate, skipped };
+}
+
+// src/commands/remove.ts
+function removeCommand(opts) {
+  const lock = loadLockfile(opts.cwd);
+  const removed = [];
+  const missing = [];
+  const prefix = opts.dryRun ? "[dry-run] " : "";
+  for (const name of opts.names) {
+    const locked = lock.skills[name];
+    if (!locked) {
+      log.warn(`"${name}" is not installed.`);
+      missing.push(name);
+      continue;
+    }
+    const targets = (opts.targets?.length ? opts.targets : Object.keys(locked.emitted)).filter((t) => locked.emitted[t]);
+    const wholeRemoved = [];
+    for (const t of targets) {
+      const e = locked.emitted[t];
+      for (const file of e.files) {
+        if (removeWholeFile(opts.cwd, file, opts.dryRun)) {
+          wholeRemoved.push(file);
+          log.info(`${prefix}removed   ${file}`);
+        }
+      }
+      if (e.block && removeBlockFromFile(opts.cwd, e.block, name, opts.dryRun)) {
+        log.info(`${prefix}unblocked ${e.block} [${name}]`);
+      }
+      if (!opts.dryRun) delete locked.emitted[t];
+    }
+    pruneEmptyDirs(opts.cwd, wholeRemoved, opts.dryRun);
+    if (!opts.dryRun) {
+      if (Object.keys(locked.emitted).length === 0) delete lock.skills[name];
+    }
+    removed.push(name);
+  }
+  if (!opts.dryRun) saveLockfile(opts.cwd, lock);
+  log.success(`${prefix}Removed ${removed.length} skill(s).`);
+  return { removed, missing };
+}
+
+// src/commands/doctor.ts
+import { existsSync as existsSync9, readFileSync as readFileSync6 } from "fs";
+import { join as join9 } from "path";
+function doctorCommand(opts) {
+  const problems = [];
+  const note = (msg) => problems.push(msg);
+  const cfg = loadConfig(opts.cwd);
+  if (!cfg) {
+    log.warn("No skills-master.json found \u2014 run `skills-master init`.");
+  } else {
+    log.info(`Config targets: ${cfg.targets.length ? cfg.targets.join(", ") : "(auto-detect)"}`);
+  }
+  const lock = loadLockfile(opts.cwd);
+  const names = Object.keys(lock.skills);
+  if (names.length === 0) {
+    log.info("No skills installed.");
+    return { problems, ok: true };
+  }
+  for (const name of names) {
+    const locked = lock.skills[name];
+    for (const [target, e] of Object.entries(locked.emitted)) {
+      for (const file of e.files) {
+        if (!existsSync9(join9(opts.cwd, file))) note(`${name}: missing ${target} file ${file}`);
+      }
+      if (e.files.every((f) => existsSync9(join9(opts.cwd, f)))) {
+        if (diskHash(opts.cwd, e.files) !== e.hash) {
+          note(`${name}: local edits to ${target} output(s) (run \`update --overwrite\` to reset)`);
+        }
+      }
+      if (e.block) {
+        const abs = join9(opts.cwd, e.block);
+        if (!existsSync9(abs) || !hasBlock(readFileSync6(abs, "utf8"), name)) {
+          note(`${name}: missing managed block in ${e.block}`);
+        }
+      }
+    }
+  }
+  if (problems.length === 0) {
+    log.success(`All ${names.length} installed skill(s) look healthy.`);
+  } else {
+    for (const p of problems) log.warn(p);
+    log.plain(`
+${problems.length} problem(s) found.`);
+  }
+  return { problems, ok: problems.length === 0 };
+}
+
+// src/commands/catalog.ts
+async function registryOf(q) {
+  const content = await resolveContent({ content: q.content, ref: q.ref, cwd: q.cwd });
+  return content.registry();
+}
+async function listCommand(opts) {
+  const reg = await registryOf(opts);
+  let skills = reg.skills;
+  if (opts.domain) skills = skills.filter((s) => s.domain === opts.domain);
+  if (opts.class) skills = skills.filter((s) => s.class === opts.class);
+  if (opts.category) skills = skills.filter((s) => s.category === opts.category);
+  if (opts.platform) {
+    const platform = opts.platform;
+    skills = skills.filter((s) => s.platforms.includes(platform));
+  }
+  if (opts.json) {
+    log.plain(JSON.stringify(skills, null, 2));
+    return skills;
+  }
+  if (skills.length === 0) {
+    log.info("No skills match.");
+    return skills;
+  }
+  const groups = /* @__PURE__ */ new Map();
+  for (const s of skills) {
+    const key = `${s.domain}/${s.class}/${s.category}`;
+    (groups.get(key) ?? groups.set(key, []).get(key)).push(s);
+  }
+  for (const [group, entries] of [...groups].sort()) {
+    log.plain(`
+${group}`);
+    for (const s of entries) {
+      const flag = s.stability === "stable" ? "" : ` (${s.stability})`;
+      log.plain(`  ${s.name}  v${s.version}${flag}`);
+      log.plain(`      ${truncate(s.description, 96)}`);
+    }
+  }
+  log.plain(`
+${skills.length} skill(s).`);
+  return skills;
+}
+async function searchCommand(opts) {
+  const reg = await registryOf(opts);
+  const q = opts.query.toLowerCase();
+  const hits = reg.skills.filter(
+    (s) => [s.name, s.description, s.domain, s.category, s.class, ...s.tags].join(" ").toLowerCase().includes(q)
+  );
+  if (hits.length === 0) {
+    log.info(`No matches for "${opts.query}".`);
+    return hits;
+  }
+  for (const s of hits) {
+    log.plain(`${s.name}  (${s.class}/${s.category})  v${s.version}`);
+    log.plain(`    ${truncate(s.description, 96)}`);
+  }
+  log.plain(`
+${hits.length} match(es).`);
+  return hits;
+}
+async function viewCommand(opts) {
+  const content = await resolveContent({ content: opts.content, ref: opts.ref, cwd: opts.cwd });
+  const skill = content.loadSkill(opts.name);
+  const xm = skill.frontmatter["x-skills-master"];
+  if (opts.raw) {
+    log.plain(skill.body);
+    return;
+  }
+  log.plain(`${skill.name}  v${xm.version}  [${xm.domain}/${xm.class}/${xm.category}]  ${xm.stability}`);
+  log.plain(`platforms: ${xm.platforms.join(", ")}`);
+  if (xm.requires) {
+    log.plain(`requires: ${Object.entries(xm.requires).map(([k, v]) => `${k} ${v}`).join(", ")}`);
+  }
+  if (xm.pairs_with.length) log.plain(`pairs with: ${xm.pairs_with.join(", ")}`);
+  log.plain(`
+${skill.frontmatter.description}
+`);
+  log.plain(`sources:`);
+  for (const url of xm.sources) log.plain(`  ${url}`);
+  const res = Object.entries(skill.resources).filter(([, v]) => v).map(([k]) => k);
+  if (res.length) log.plain(`
+resource files: ${res.join(", ")}`);
+}
+function truncate(s, n) {
+  return s.length <= n ? s : s.slice(0, n - 1) + "\u2026";
+}
+
+// src/core/lint.ts
+var CANONICAL_HEADINGS = [
+  "## When to use",
+  "## Core guidance",
+  "## Pitfalls",
+  "## References",
+  "## See also"
+];
+var MAX_BODY_LINES = 500;
+var WARN_BODY_LINES = 450;
+function today() {
+  return (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+}
+function lintSkills(skillsRoot) {
+  const dirs = findSkillDirs(skillsRoot);
+  const diagnostics = [];
+  const loaded = [];
+  const byName = /* @__PURE__ */ new Map();
+  for (const dir of dirs) {
+    let raw;
+    try {
+      raw = loadRawSkill(dir, skillsRoot);
+    } catch (err) {
+      diagnostics.push({
+        relPath: relPathOf(skillsRoot, dir),
+        level: "error",
+        message: `failed to parse SKILL.md: ${err instanceof Error ? err.message.split("\n")[0] : String(err)}`
+      });
+      continue;
+    }
+    for (const line of raw.rawText.split("\n")) {
+      const m = /^(\s*)(name|description|category):\s+(?!["'])(.*\s#.*)$/.exec(line);
+      if (m) {
+        diagnostics.push({
+          relPath: raw.relPath,
+          level: "warn",
+          message: `frontmatter "${m[2]}" contains " #", which YAML reads as a comment \u2014 quote the value`
+        });
+      }
+    }
+    const v = validateFrontmatter(raw.data);
+    if (!v.ok) {
+      for (const issue of v.issues) {
+        diagnostics.push({ relPath: raw.relPath, level: "error", message: issue });
+      }
+      loaded.push({ relPath: raw.relPath, folderName: raw.folderName, body: raw.body });
+      continue;
+    }
+    loaded.push({ relPath: raw.relPath, folderName: raw.folderName, fm: v.value, body: raw.body });
+    byName.set(v.value.name, v.value);
+  }
+  const nameDirs = /* @__PURE__ */ new Map();
+  for (const s of loaded) {
+    const n = s.fm?.name ?? s.folderName;
+    (nameDirs.get(n) ?? nameDirs.set(n, []).get(n)).push(s.relPath);
+  }
+  for (const [name, paths] of nameDirs) {
+    if (paths.length > 1) {
+      for (const p of paths) {
+        diagnostics.push({ relPath: p, level: "error", message: `duplicate skill name "${name}" (also at ${paths.filter((x) => x !== p).join(", ")})` });
+      }
+    }
+  }
+  const todayStr = today();
+  for (const s of loaded) {
+    const push = (level, message) => diagnostics.push({ relPath: s.relPath, level, message });
+    if (!s.fm) continue;
+    const fm = s.fm;
+    const xm = fm["x-skills-master"];
+    if (fm.name !== s.folderName) {
+      push("error", `name "${fm.name}" must equal the folder name "${s.folderName}"`);
+    }
+    if (!/use when/i.test(fm.description)) {
+      push("warn", `description should include a "Use when ..." trigger clause`);
+    }
+    if (xm.snapshot_date > todayStr) {
+      push("error", `snapshot_date ${xm.snapshot_date} is in the future`);
+    }
+    if (xm.stability === "contested" && !/^## Open question\b/m.test(s.body)) {
+      push("error", `stability is "contested" but no "## Open question" section is present`);
+    }
+    const lineCount = s.body.split("\n").length;
+    if (lineCount > MAX_BODY_LINES) {
+      push("error", `SKILL.md body is ${lineCount} lines (max ${MAX_BODY_LINES}); move depth into reference.md/examples.md`);
+    } else if (lineCount > WARN_BODY_LINES) {
+      push("warn", `SKILL.md body is ${lineCount} lines (approaching the ${MAX_BODY_LINES}-line cap)`);
+    }
+    if (!s.relPath.startsWith(`${xm.domain}/`)) {
+      push("warn", `domain "${xm.domain}" does not match the top folder of "${s.relPath}"`);
+    }
+    if (xm.sources.length === 0) {
+      push("warn", `no sources \u2014 add at least one canonical documentation URL`);
+    }
+    for (const url of xm.sources) {
+      if (!/^https:\/\//.test(url)) {
+        push("warn", `sources entry should be an https URL: ${url}`);
+      }
+    }
+    for (const heading of CANONICAL_HEADINGS) {
+      if (!s.body.includes(heading)) {
+        push("warn", `missing recommended section "${heading}"`);
+      }
+    }
+    for (const partner of xm.pairs_with) {
+      const partnerFm = byName.get(partner);
+      if (!partnerFm) {
+        push("error", `pairs_with references unknown skill "${partner}"`);
+        continue;
+      }
+      if (!partnerFm["x-skills-master"].pairs_with.includes(fm.name)) {
+        push("error", `pairs_with "${partner}" is not reciprocated (add "${fm.name}" to its pairs_with)`);
+      }
+    }
+  }
+  const errorCount = diagnostics.filter((d) => d.level === "error").length;
+  const warnCount = diagnostics.filter((d) => d.level === "warn").length;
+  return { diagnostics, skillCount: dirs.length, errorCount, warnCount };
+}
+
+// src/commands/lint.ts
+async function lintCommand(opts) {
+  const content = await resolveContent({ content: opts.content, cwd: opts.cwd });
+  const result = lintSkills(content.root);
+  for (const d of result.diagnostics) {
+    const line = `${d.level === "error" ? "\u2717" : "!"} ${d.relPath}: ${d.message}`;
+    if (d.level === "error") log.error(line);
+    else log.warn(line);
+  }
+  log.plain(
+    `
+Linted ${result.skillCount} skill(s): ${result.errorCount} error(s), ${result.warnCount} warning(s).`
+  );
+  return result.errorCount === 0;
+}
+
+// src/commands/registry.ts
+import { existsSync as existsSync10, readFileSync as readFileSync7, writeFileSync as writeFileSync4 } from "fs";
+import { join as join10 } from "path";
+
+// src/schema/registry.ts
+import { z as z4 } from "zod";
+var RegistryEntrySchema = z4.object({
+  name: z4.string(),
+  domain: z4.string(),
+  class: SkillClassSchema,
+  category: z4.string(),
+  description: z4.string(),
+  platforms: z4.array(z4.string()),
+  stability: StabilitySchema,
+  version: z4.string(),
+  tags: z4.array(z4.string()).default([]),
+  pairs_with: z4.array(z4.string()).default([]),
+  /** path relative to the skills root. */
+  path: z4.string(),
+  /** which on-demand resource files exist. */
+  resources: z4.object({
+    reference: z4.boolean(),
+    examples: z4.boolean(),
+    checklist: z4.boolean()
+  })
+});
+var RegistrySchema = z4.object({
+  $schema: z4.string().optional(),
+  /** aggregate library version (bumped on release). */
+  version: z4.string().default("0.1.0"),
+  generatedAt: z4.string().optional(),
+  skills: z4.array(RegistryEntrySchema).default([])
+});
+var REGISTRY_FILENAME = "registry.json";
+
+// src/commands/registry.ts
+async function registryBuildCommand(opts) {
+  const content = await resolveContent({ content: opts.content, cwd: opts.cwd });
+  const registry2 = buildRegistry(content.root, opts.version ?? "0.1.0");
+  const json = JSON.stringify(registry2, null, 2) + "\n";
+  const outPath = join10(content.root, REGISTRY_FILENAME);
+  if (opts.check) {
+    const current = existsSync10(outPath) ? readFileSync7(outPath, "utf8") : "";
+    if (current !== json) {
+      log.error(`registry.json is out of date \u2014 run \`registry build\` and commit the result.`);
+      return false;
+    }
+    log.success(`registry.json is up to date (${registry2.skills.length} skills).`);
+    return true;
+  }
+  writeFileSync4(outPath, json, "utf8");
+  log.success(`Wrote ${REGISTRY_FILENAME} (${registry2.skills.length} skills).`);
+  return true;
+}
+
+// src/commands/marketplace.ts
+import { mkdirSync as mkdirSync2, writeFileSync as writeFileSync5 } from "fs";
+import { dirname as dirname2, join as join11, resolve as resolve2 } from "path";
+var CLASS_LABEL = {
+  code: "code skills (frameworks & APIs)",
+  design: "design-review skills",
+  "lang-tooling": "language, build, test & ship skills",
+  overview: "decision-guidance routers"
+};
+var CLASS_CATEGORY = {
+  code: "development",
+  design: "design",
+  "lang-tooling": "development",
+  overview: "development"
+};
+function pluginName(domain, cls) {
+  const clsSeg = cls === "overview" ? "overviews" : cls;
+  return `skills-master-${domain}-${clsSeg}`;
+}
+function titleCase(s) {
+  return s.charAt(0).toUpperCase() + s.slice(1);
+}
+async function marketplaceBuildCommand(opts) {
+  const content = await resolveContent({ content: opts.content, cwd: opts.cwd });
+  const out = resolve2(opts.out ?? dirname2(content.root));
+  const version = opts.version ?? "0.1.0";
+  const groups = /* @__PURE__ */ new Map();
+  for (const dir of content.skillDirs()) {
+    const skill = content.loadSkill(dir.split(/[\\/]/).pop());
+    const xm = skill.frontmatter["x-skills-master"];
+    const key = `${xm.domain}:${xm.class}`;
+    const name = pluginName(xm.domain, xm.class);
+    const ctx = {
+      projectRoot: out,
+      paths: {
+        claude: `plugins/${name}/skills`,
+        cursor: "",
+        copilot: "",
+        agents: ""
+      }
+    };
+    const files = claudeEmitter.emit(skill, ctx);
+    const g = groups.get(key) ?? { domain: xm.domain, cls: xm.class, files: [], count: 0 };
+    g.files.push(...files);
+    g.count += 1;
+    groups.set(key, g);
+  }
+  const plugins = [];
+  for (const { domain, cls, files, count } of groups.values()) {
+    const name = pluginName(domain, cls);
+    applyFiles(out, files, { overwrite: true });
+    const description = `${titleCase(domain)} ${CLASS_LABEL[cls]}.`;
+    const pluginDir = join11(out, "plugins", name, ".claude-plugin");
+    mkdirSync2(pluginDir, { recursive: true });
+    const manifest = {
+      name,
+      version,
+      description,
+      author: { name: "skills-master contributors" }
+    };
+    writeFileSync5(join11(pluginDir, "plugin.json"), JSON.stringify(manifest, null, 2) + "\n", "utf8");
+    plugins.push({ name, source: `./plugins/${name}`, description, version, category: CLASS_CATEGORY[cls] });
+    log.info(`Built ${name} (${count} skills).`);
+  }
+  plugins.sort((a, b) => a.name.localeCompare(b.name));
+  const marketplace2 = {
+    $schema: "https://www.schemastore.org/claude-code-marketplace.json",
+    name: "skills-master",
+    owner: { name: "skills-master contributors" },
+    plugins
+  };
+  const mpDir = join11(out, ".claude-plugin");
+  mkdirSync2(mpDir, { recursive: true });
+  writeFileSync5(join11(mpDir, "marketplace.json"), JSON.stringify(marketplace2, null, 2) + "\n", "utf8");
+  log.success(`Wrote .claude-plugin/marketplace.json (${plugins.length} plugins).`);
+}
+
+// src/commands/new.ts
+import { existsSync as existsSync11, mkdirSync as mkdirSync3, writeFileSync as writeFileSync6 } from "fs";
+import { join as join12 } from "path";
+function template(domain, cls, category, name) {
+  const today2 = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  return `---
+name: ${name}
+description: TODO \u2014 one-line, third person. Use when <triggers go here>.
+globs:
+  - "**/*"
+tags: []
+x-skills-master:
+  domain: ${domain}
+  class: ${cls}
+  category: ${category}
+  platforms: [${domain}]
+  requires: {}
+  pairs_with: []
+  sources: []
+  snapshot_date: "${today2}"
+  stability: emerging
+  version: 0.1.0
+---
+
+## When to use
+
+TODO \u2014 when should an agent reach for this skill?
+
+## Core guidance
+
+TODO \u2014 the do/don't, idioms, and best practices (original prose, no copied docs).
+
+## Platform notes
+
+TODO \u2014 platform-specific caveats.
+
+## Pitfalls
+
+TODO \u2014 common mistakes.
+
+## References
+
+- **Documentation:** [TODO](https://developer.apple.com/documentation/...)
+- **Human Interface Guidelines:** [TODO](https://developer.apple.com/design/human-interface-guidelines/...)
+- **WWDC:** [TODO](https://developer.apple.com/videos/...)
+
+## See also
+
+TODO \u2014 paired skills referenced by name.
+`;
+}
+async function newSkillCommand(opts) {
+  const parts = opts.spec.split("/").filter(Boolean);
+  if (parts.length < 4) {
+    throw new Error(`Expected "domain/class/category/name", got "${opts.spec}".`);
+  }
+  const domain = parts[0];
+  const cls = SkillClassSchema.parse(parts[1]);
+  const category = parts[2];
+  const name = parts[parts.length - 1];
+  const content = await resolveContent({ content: opts.content, cwd: opts.cwd });
+  const dir = join12(content.root, domain, CLASS_DIR[cls], ...parts.slice(2));
+  const skillMd = join12(dir, "SKILL.md");
+  if (existsSync11(skillMd) && !opts.force) {
+    throw new Error(`Skill already exists at ${skillMd} (use --force to overwrite).`);
+  }
+  mkdirSync3(dir, { recursive: true });
+  writeFileSync6(skillMd, template(domain, cls, category, name), "utf8");
+  log.success(`Created ${skillMd}`);
+  return skillMd;
+}
+
+// src/bin.ts
+var VALID = new Set(ALL_TARGETS);
+function parseTargets(value) {
+  if (!value) return void 0;
+  if (value === "all") return ALL_TARGETS;
+  const ids = value.split(",").map((s) => s.trim()).filter(Boolean);
+  for (const id of ids) {
+    if (!VALID.has(id)) {
+      throw new Error(`Unknown target "${id}". Valid: ${[...VALID, "all"].join(", ")}.`);
+    }
+  }
+  return ids;
+}
+async function run(fn, exitOnFalse = false) {
+  try {
+    const result = await fn();
+    if (exitOnFalse && result === false) process.exitCode = 1;
+  } catch (err) {
+    log.error(err instanceof Error ? err.message : String(err));
+    process.exitCode = 1;
+  }
+}
+var program = new Command();
+program.name("skills-master").description("Install tool-agnostic Apple development skills into any AI coding tool.").version("0.1.0");
+program.command("init").description("Detect tools and write skills-master.json").option("--target <list>", "comma list or 'all'").option("--ref <ref>", "content git ref").option("--no-commit", "gitignore generated files instead of committing them").option("--force", "overwrite an existing config").action(
+  (opts) => run(
+    () => initCommand({
+      cwd: process.cwd(),
+      targets: parseTargets(opts.target),
+      commit: opts.commit,
+      contentRef: opts.ref,
+      force: opts.force
+    })
+  )
+);
+program.command("list").description("List available skills").option("--domain <domain>", "e.g. apple, android").option("--class <class>").option("--category <category>").option("--platform <platform>").option("--json").option("--content <dir>", "local skills directory").option("--ref <ref>").action(
+  (opts) => run(
+    () => listCommand({
+      cwd: process.cwd(),
+      domain: opts.domain,
+      class: opts.class,
+      category: opts.category,
+      platform: opts.platform,
+      json: opts.json,
+      content: opts.content,
+      ref: opts.ref
+    })
+  )
+);
+program.command("search <query>").description("Search skills by name, description, tags").option("--content <dir>").option("--ref <ref>").action(
+  (query, opts) => run(() => searchCommand({ cwd: process.cwd(), query, content: opts.content, ref: opts.ref }))
+);
+program.command("view <name>").description("Show a skill's metadata and body").option("--raw", "print the raw SKILL.md body").option("--content <dir>").option("--ref <ref>").action(
+  (name, opts) => run(
+    () => viewCommand({ cwd: process.cwd(), name, raw: opts.raw, content: opts.content, ref: opts.ref })
+  )
+);
+program.command("add <names...>").description("Install skills (by name, category, or class) into your tools").option("--target <list>", "comma list or 'all'").option("--with-pairs", "also install paired (code<->design) skills").option("--dry-run", "preview without writing").option("--overwrite", "overwrite changed files without asking").option("--content <dir>").option("--ref <ref>").action(
+  (names, opts) => run(
+    () => addCommand({
+      cwd: process.cwd(),
+      names,
+      targets: parseTargets(opts.target),
+      withPairs: opts.withPairs,
+      dryRun: opts.dryRun,
+      overwrite: opts.overwrite,
+      content: opts.content,
+      ref: opts.ref
+    })
+  )
+);
+program.command("update [names...]").description("Re-install skills whose content changed").option("--dry-run").option("--overwrite", "force re-install, replacing local edits").option("--content <dir>").option("--ref <ref>").action(
+  (names, opts) => run(
+    () => updateCommand({
+      cwd: process.cwd(),
+      names,
+      dryRun: opts.dryRun,
+      overwrite: opts.overwrite,
+      content: opts.content,
+      ref: opts.ref
+    })
+  )
+);
+program.command("remove <names...>").description("Remove installed skills").option("--target <list>", "comma list or 'all'").option("--dry-run").action(
+  (names, opts) => run(
+    () => removeCommand({ cwd: process.cwd(), names, targets: parseTargets(opts.target), dryRun: opts.dryRun })
+  )
+);
+program.command("doctor").description("Check installed skills for drift and missing files").action(() => run(() => doctorCommand({ cwd: process.cwd() })));
+program.command("lint").description("Validate the skill library (maintainer command)").option("--content <dir>").action((opts) => run(() => lintCommand({ cwd: process.cwd(), content: opts.content }), true));
+program.command("new <spec>").description("Scaffold a new skill: class/category/name (maintainer command)").option("--content <dir>").option("--force").action(
+  (spec, opts) => run(() => newSkillCommand({ cwd: process.cwd(), spec, content: opts.content, force: opts.force }))
+);
+var registry = program.command("registry").description("Registry maintenance");
+registry.command("build").description("Generate registry.json from the skill tree").option("--content <dir>").option("--check", "verify the committed registry.json is current (CI)").option("--version <v>").action(
+  (opts) => run(
+    () => registryBuildCommand({ cwd: process.cwd(), content: opts.content, check: opts.check, version: opts.version }),
+    true
+  )
+);
+var marketplace = program.command("marketplace").description("Claude marketplace maintenance");
+marketplace.command("build").description("Generate .claude-plugin/marketplace.json and per-class plugins").option("--content <dir>").option("--out <dir>", "output root").option("--version <v>").action(
+  (opts) => run(
+    () => marketplaceBuildCommand({ cwd: process.cwd(), content: opts.content, out: opts.out, version: opts.version })
+  )
+);
+program.parseAsync(process.argv);
+//# sourceMappingURL=bin.js.map