@channlize/skills 0.0.0-stage → 0.5.0

package/dist/cli.js

@@ -0,0 +1,841 @@
+#!/usr/bin/env node
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/cli.ts
+var cli_exports = {};
+__export(cli_exports, {
+  main: () => main,
+  parseArgs: () => parseArgs
+});
+module.exports = __toCommonJS(cli_exports);
+var import_node_fs4 = require("fs");
+var import_promises = require("readline/promises");
+var import_node_path4 = require("path");
+
+// src/catalog.ts
+var import_node_fs = require("fs");
+var import_node_path = require("path");
+
+// src/frontmatter.ts
+function unquote(raw) {
+  const v = raw.trim();
+  if (v.length >= 2 && v.startsWith('"') && v.endsWith('"')) {
+    return v.slice(1, -1).replace(/\\"/g, '"').replace(/\\\\/g, "\\");
+  }
+  if (v.length >= 2 && v.startsWith("'") && v.endsWith("'")) {
+    return v.slice(1, -1).replace(/''/g, "'");
+  }
+  return v;
+}
+function parseSkillFile(text) {
+  const src = text.replace(/^\uFEFF/, "").replace(/\r\n/g, "\n");
+  if (!src.startsWith("---\n")) {
+    return { data: null, body: src, errors: [] };
+  }
+  const end = src.indexOf("\n---", 4);
+  if (end === -1) {
+    return {
+      data: null,
+      body: src,
+      errors: ["frontmatter is not closed with ---"]
+    };
+  }
+  const block = src.slice(4, end);
+  const afterFence = src.indexOf("\n", end + 1);
+  const body = afterFence === -1 ? "" : src.slice(afterFence + 1);
+  const data = {};
+  const errors = [];
+  let currentMap = null;
+  block.split("\n").forEach((line, i) => {
+    const lineNo = i + 2;
+    if (!line.trim() || line.trimStart().startsWith("#")) return;
+    const nested = /^\s+([A-Za-z0-9_.-]+):\s*(.*)$/.exec(line);
+    if (nested && currentMap) {
+      currentMap[nested[1]] = unquote(nested[2]);
+      return;
+    }
+    const top = /^([A-Za-z0-9_-]+):\s*(.*)$/.exec(line);
+    if (!top) {
+      errors.push(`line ${lineNo}: expected "key: value"`);
+      return;
+    }
+    const [, key, rawValue] = top;
+    if (key in data) errors.push(`line ${lineNo}: duplicate key "${key}"`);
+    if (rawValue === "") {
+      currentMap = {};
+      data[key] = currentMap;
+      return;
+    }
+    currentMap = null;
+    if (/^[>|][+-]?$/.test(rawValue.trim())) {
+      errors.push(
+        `line ${lineNo}: "${key}" uses a block scalar; write it on one line`
+      );
+      return;
+    }
+    if (rawValue.trim().startsWith("[") || rawValue.trim().startsWith("{")) {
+      errors.push(`line ${lineNo}: "${key}" must be a plain string`);
+      return;
+    }
+    data[key] = unquote(rawValue);
+  });
+  return { data, body, errors };
+}
+
+// src/catalog.ts
+function packageRoot() {
+  return (0, import_node_path.resolve)(__dirname, "..");
+}
+function bundledSkillsDir() {
+  return (0, import_node_path.join)(packageRoot(), "skills");
+}
+function packageVersion() {
+  const pkg = JSON.parse(
+    (0, import_node_fs.readFileSync)((0, import_node_path.join)(packageRoot(), "package.json"), "utf8")
+  );
+  return pkg.version;
+}
+function listSkillFiles(dir) {
+  const out2 = [];
+  const walk = (d) => {
+    for (const entry of (0, import_node_fs.readdirSync)(d).sort()) {
+      if (entry.startsWith(".")) continue;
+      const full = (0, import_node_path.join)(d, entry);
+      if ((0, import_node_fs.statSync)(full).isDirectory()) walk(full);
+      else out2.push((0, import_node_path.relative)(dir, full).split(import_node_path.sep).join("/"));
+    }
+  };
+  walk(dir);
+  return out2.sort(
+    (a, b) => a === "SKILL.md" ? -1 : b === "SKILL.md" ? 1 : a.localeCompare(b)
+  );
+}
+function skillFolders(root) {
+  return (0, import_node_fs.readdirSync)(root).filter((e) => !e.startsWith(".") && (0, import_node_fs.statSync)((0, import_node_path.join)(root, e)).isDirectory()).sort();
+}
+function loadSkills(root = bundledSkillsDir()) {
+  return skillFolders(root).flatMap((folder) => {
+    const dir = (0, import_node_path.join)(root, folder);
+    let text;
+    try {
+      text = (0, import_node_fs.readFileSync)((0, import_node_path.join)(dir, "SKILL.md"), "utf8");
+    } catch {
+      return [];
+    }
+    const { data } = parseSkillFile(text);
+    const name = typeof data?.name === "string" ? data.name : folder;
+    const description = typeof data?.description === "string" ? data.description : "";
+    const metadata = data && typeof data.metadata === "object" ? data.metadata : {};
+    const files = listSkillFiles(dir).map((path) => ({
+      path,
+      content: (0, import_node_fs.readFileSync)((0, import_node_path.join)(dir, path), "utf8")
+    }));
+    return [{ name, description, dir, metadata, files }];
+  });
+}
+function loadPrompts(file = (0, import_node_path.join)(packageRoot(), "prompts.json")) {
+  return JSON.parse((0, import_node_fs.readFileSync)(file, "utf8"));
+}
+var PROMPT_PLACEHOLDERS = [
+  "projectId",
+  "widgetKey",
+  "react",
+  "core",
+  "mcp"
+];
+function placeholdersOf(template) {
+  return [...template.matchAll(/\{\{\s*([A-Za-z0-9_]+)\s*\}\}/g)].map(
+    (m) => m[1]
+  );
+}
+function fillPrompt(template, library, values = {}) {
+  const map = {
+    projectId: values.projectId || "<your-project-id>",
+    widgetKey: values.widgetKey || "<your-widget-key (wk_\u2026)>",
+    ...library.versions
+  };
+  return template.replace(
+    /\{\{\s*([A-Za-z0-9_]+)\s*\}\}/g,
+    (whole, key) => map[key] ?? whole
+  );
+}
+function buildCatalog() {
+  return {
+    package: "@channlize/skills",
+    version: packageVersion(),
+    skills: loadSkills().map(({ dir: _dir, ...rest }) => rest),
+    prompts: loadPrompts()
+  };
+}
+
+// src/install.ts
+var import_node_crypto = require("crypto");
+var import_node_fs2 = require("fs");
+var import_node_os = require("os");
+var import_node_path2 = require("path");
+var TARGETS = {
+  claude: {
+    label: "Claude Code",
+    project: ".claude/skills",
+    user: ".claude/skills"
+  },
+  cursor: {
+    label: "Cursor",
+    project: ".cursor/skills",
+    user: ".cursor/skills"
+  },
+  codex: {
+    label: "Codex (and other .agents readers)",
+    project: ".agents/skills",
+    user: ".agents/skills"
+  },
+  copilot: {
+    label: "VS Code / GitHub Copilot",
+    project: ".github/skills",
+    user: ".copilot/skills"
+  }
+};
+var TARGET_IDS = Object.keys(TARGETS);
+var ALL_TARGETS = ["claude", "codex", "copilot"];
+var MANIFEST = ".channlize-skill.json";
+function targetDir(target, scope, cwd = process.cwd(), home = (0, import_node_os.homedir)()) {
+  const t = TARGETS[target];
+  return scope === "user" ? (0, import_node_path2.join)(home, t.user) : (0, import_node_path2.resolve)(cwd, t.project);
+}
+var sha256 = (s) => (0, import_node_crypto.createHash)("sha256").update(s).digest("hex");
+function readManifest(skillDir) {
+  try {
+    return JSON.parse(
+      (0, import_node_fs2.readFileSync)((0, import_node_path2.join)(skillDir, MANIFEST), "utf8")
+    );
+  } catch {
+    return null;
+  }
+}
+async function installSkills(opts) {
+  const results = [];
+  for (const skill of opts.skills) {
+    const skillDir = (0, import_node_path2.join)(opts.dir, skill.name);
+    const previous = readManifest(skillDir);
+    const manifest = {
+      package: "@channlize/skills",
+      version: opts.version,
+      files: {}
+    };
+    for (const file of skill.files) {
+      const dest = (0, import_node_path2.join)(skillDir, file.path);
+      const next = sha256(file.content);
+      const result = {
+        skill: skill.name,
+        path: file.path,
+        dest,
+        action: "created"
+      };
+      if ((0, import_node_fs2.existsSync)(dest)) {
+        const current = sha256((0, import_node_fs2.readFileSync)(dest, "utf8"));
+        const recorded = previous?.files[file.path];
+        if (current === next) {
+          result.action = "unchanged";
+        } else if (recorded && current === recorded) {
+          result.action = "updated";
+        } else if (opts.force || opts.confirm && await opts.confirm({ ...result, action: "overwritten" })) {
+          result.action = "overwritten";
+        } else {
+          result.action = "kept";
+        }
+      }
+      if (!opts.dryRun && (result.action === "created" || result.action === "updated" || result.action === "overwritten")) {
+        (0, import_node_fs2.mkdirSync)((0, import_node_path2.dirname)(dest), { recursive: true });
+        (0, import_node_fs2.writeFileSync)(dest, file.content);
+      }
+      manifest.files[file.path] = result.action === "kept" ? previous?.files[file.path] ?? "" : next;
+      results.push(result);
+    }
+    if (!opts.dryRun) {
+      (0, import_node_fs2.mkdirSync)(skillDir, { recursive: true });
+      (0, import_node_fs2.writeFileSync)(
+        (0, import_node_path2.join)(skillDir, MANIFEST),
+        JSON.stringify(manifest, null, 2) + "\n"
+      );
+    }
+  }
+  return results;
+}
+
+// src/validate.ts
+var import_node_fs3 = require("fs");
+var import_node_path3 = require("path");
+var NAME_RE = /^[a-z0-9]+(-[a-z0-9]+)*$/;
+var NAME_MAX = 64;
+var DESCRIPTION_MAX = 1024;
+var COMPATIBILITY_MAX = 500;
+var BODY_MAX_LINES = 500;
+var SPEC_KEYS = [
+  "name",
+  "description",
+  "license",
+  "compatibility",
+  "metadata",
+  "allowed-tools"
+];
+function displayPath(p) {
+  const rel = (0, import_node_path3.relative)(process.cwd(), p);
+  return rel && !rel.startsWith("..") ? rel : p;
+}
+function extractLinks(markdown) {
+  const prose = markdown.replace(/^[ \t]*(```|~~~)[^\n]*\n[\s\S]*?^[ \t]*\1[^\n]*$/gm, "").replace(/`[^`\n]*`/g, "");
+  const links = /* @__PURE__ */ new Set();
+  for (const m of prose.matchAll(
+    /\[[^\]]*\]\(\s*<?([^)\s>]+)>?(?:\s+"[^"]*")?\s*\)/g
+  ))
+    links.add(m[1]);
+  for (const m of prose.matchAll(/https?:\/\/[^\s<>)\]"'`]+/g))
+    links.add(m[0].replace(/[.,;:!?]+$/, ""));
+  return [...links];
+}
+function validateSkill(dir) {
+  const folder = dir.split(import_node_path3.sep).pop() ?? dir;
+  const issues = [];
+  const urls = /* @__PURE__ */ new Map();
+  const skillFile = (0, import_node_path3.join)(dir, "SKILL.md");
+  const at = (file) => displayPath((0, import_node_path3.join)(dir, file));
+  if (!(0, import_node_fs3.existsSync)(skillFile)) {
+    issues.push({ file: at("SKILL.md"), message: "missing SKILL.md" });
+    return { issues, urls };
+  }
+  const { data, body, errors } = parseSkillFile(
+    (0, import_node_fs3.readFileSync)(skillFile, "utf8")
+  );
+  for (const e of errors)
+    issues.push({ file: at("SKILL.md"), message: `frontmatter ${e}` });
+  if (!data) {
+    issues.push({
+      file: at("SKILL.md"),
+      message: "no YAML frontmatter (the file must start with ---)"
+    });
+  } else {
+    const { name, description, compatibility, metadata } = data;
+    if (typeof name !== "string" || !name) {
+      issues.push({ file: at("SKILL.md"), message: '"name" is required' });
+    } else {
+      if (name.length > NAME_MAX)
+        issues.push({
+          file: at("SKILL.md"),
+          message: `"name" is over ${NAME_MAX} characters`
+        });
+      if (!NAME_RE.test(name)) {
+        issues.push({
+          file: at("SKILL.md"),
+          message: `"name" must be lowercase letters, digits and single hyphens: "${name}"`
+        });
+      }
+      if (name !== folder)
+        issues.push({
+          file: at("SKILL.md"),
+          message: `"name" (${name}) must match its folder (${folder})`
+        });
+    }
+    if (typeof description !== "string" || !description.trim()) {
+      issues.push({
+        file: at("SKILL.md"),
+        message: '"description" is required'
+      });
+    } else if (description.length > DESCRIPTION_MAX) {
+      issues.push({
+        file: at("SKILL.md"),
+        message: `"description" is ${description.length} characters; the limit is ${DESCRIPTION_MAX}`
+      });
+    }
+    if (compatibility !== void 0 && (typeof compatibility !== "string" || compatibility.length > COMPATIBILITY_MAX)) {
+      issues.push({
+        file: at("SKILL.md"),
+        message: `"compatibility" must be a string of at most ${COMPATIBILITY_MAX} characters`
+      });
+    }
+    if (metadata !== void 0 && typeof metadata !== "object") {
+      issues.push({
+        file: at("SKILL.md"),
+        message: '"metadata" must be a map of strings'
+      });
+    }
+    for (const key of Object.keys(data)) {
+      if (!SPEC_KEYS.includes(key)) {
+        issues.push({
+          file: at("SKILL.md"),
+          message: `unknown frontmatter key "${key}" (allowed: ${SPEC_KEYS.join(", ")})`
+        });
+      }
+    }
+  }
+  if (!body.trim())
+    issues.push({ file: at("SKILL.md"), message: "the body is empty" });
+  const lines = body.split("\n").length;
+  if (lines > BODY_MAX_LINES)
+    issues.push({
+      file: at("SKILL.md"),
+      message: `the body has ${lines} lines; keep it under ${BODY_MAX_LINES}`
+    });
+  for (const file of listSkillFiles(dir).filter((f) => f.endsWith(".md"))) {
+    const text = (0, import_node_fs3.readFileSync)((0, import_node_path3.join)(dir, file), "utf8");
+    for (const link of extractLinks(text)) {
+      if (/^https?:\/\//.test(link)) {
+        if (!urls.has(link)) urls.set(link, at(file));
+        continue;
+      }
+      if (/^(mailto:|#)/.test(link)) continue;
+      const target = (0, import_node_path3.normalize)(
+        (0, import_node_path3.join)((0, import_node_path3.dirname)((0, import_node_path3.join)(dir, file)), decodeURI(link.split("#")[0]))
+      );
+      if (!target.startsWith((0, import_node_path3.resolve)(dir) + import_node_path3.sep)) {
+        issues.push({
+          file: at(file),
+          message: `link "${link}" points outside the skill folder`
+        });
+      } else if (!(0, import_node_fs3.existsSync)(target)) {
+        issues.push({ file: at(file), message: `broken link "${link}"` });
+      }
+    }
+  }
+  return { issues, urls };
+}
+function validatePrompts(library, skillNames, file = "prompts.json") {
+  const issues = [];
+  const ids = /* @__PURE__ */ new Set();
+  for (const [i, p] of library.prompts.entries()) {
+    const where = `${file} prompts[${i}] (${p.id ?? "?"})`;
+    const add = (message) => issues.push({ file: where, message });
+    if (!p.id || !NAME_RE.test(p.id)) add('"id" must be kebab-case');
+    if (ids.has(p.id)) add("duplicate id");
+    ids.add(p.id);
+    if (!p.title?.trim()) add('"title" is required');
+    if (!library.categories[p.category])
+      add(`unknown category "${p.category}"`);
+    if (!Array.isArray(p.frameworks)) add('"frameworks" must be an array');
+    if (!Array.isArray(p.skills) || p.skills.length === 0)
+      add('"skills" must list at least one skill');
+    for (const s of p.skills ?? [])
+      if (!skillNames.includes(s)) add(`unknown skill "${s}"`);
+    for (const ph of placeholdersOf(p.prompt ?? "")) {
+      if (!PROMPT_PLACEHOLDERS.includes(ph))
+        add(`unknown placeholder {{${ph}}}`);
+    }
+    const text = p.prompt ?? "";
+    for (const s of p.skills ?? [])
+      if (!text.includes(s))
+        add(`the prompt should tell the assistant to read the ${s} skill`);
+    if (!/\bverify\b/i.test(text))
+      add('the prompt should end with a verification step ("Verify: \u2026")');
+    if (/ch_live_[A-Za-z0-9]{6,}/.test(text))
+      add("the prompt contains what looks like a real server key");
+  }
+  for (const key of PROMPT_PLACEHOLDERS.slice(2)) {
+    if (!library.versions?.[key])
+      issues.push({ file, message: `versions.${key} is missing` });
+  }
+  return issues;
+}
+function validateMarketplace(root) {
+  const file = (0, import_node_path3.join)(root, ".claude-plugin", "marketplace.json");
+  const issues = [];
+  const add = (message) => issues.push({ file: displayPath(file), message });
+  let m;
+  try {
+    m = JSON.parse((0, import_node_fs3.readFileSync)(file, "utf8"));
+  } catch (e) {
+    add(`cannot read: ${e.message}`);
+    return issues;
+  }
+  const idPart = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
+  if (typeof m.name !== "string" || !idPart.test(m.name) || m.name.includes(".."))
+    add('"name" is missing or invalid');
+  if (typeof m.owner?.name !== "string" || !m.owner.name)
+    add('"owner.name" is required');
+  if (!Array.isArray(m.plugins) || m.plugins.length === 0)
+    add('"plugins" must list at least one plugin');
+  for (const [i, p] of (m.plugins ?? []).entries()) {
+    if (typeof p.name !== "string" || !idPart.test(p.name))
+      add(`plugins[${i}].name is invalid`);
+    if (typeof p.source === "string") {
+      if (!p.source.startsWith("./") && p.source !== ".")
+        add(`plugins[${i}].source must start with "./"`);
+      if (p.source.split("/").includes(".."))
+        add(`plugins[${i}].source must not contain ".."`);
+      const dir = (0, import_node_path3.resolve)(root, p.source);
+      const manifest = (0, import_node_path3.join)(dir, ".claude-plugin", "plugin.json");
+      if (!(0, import_node_fs3.existsSync)(dir) || !(0, import_node_fs3.statSync)(dir).isDirectory()) {
+        add(`plugins[${i}].source ${p.source} does not exist`);
+      } else if ((0, import_node_fs3.existsSync)(manifest)) {
+        const pj = JSON.parse((0, import_node_fs3.readFileSync)(manifest, "utf8"));
+        if (pj.name !== p.name)
+          add(
+            `plugins[${i}].name (${String(p.name)}) differs from plugin.json name (${pj.name})`
+          );
+      }
+    } else if (!p.source || typeof p.source !== "object" || typeof p.source.source !== "string") {
+      add(`plugins[${i}].source must be a "./" path or a source object`);
+    }
+  }
+  return issues;
+}
+async function checkUrls(urls, { retries = 2, timeoutMs = 15e3 } = {}) {
+  const issues = [];
+  const probe = async (url) => {
+    const npm = /^https:\/\/www\.npmjs\.com\/package\/(.+)$/.exec(url);
+    if (npm) url = `https://registry.npmjs.org/${npm[1].replace("/", "%2F")}`;
+    for (const method of ["HEAD", "GET"]) {
+      const res = await fetch(url, {
+        method,
+        redirect: "follow",
+        signal: AbortSignal.timeout(timeoutMs)
+      });
+      if (res.status < 400) return res.status;
+      if (method === "GET") return res.status;
+    }
+    return 0;
+  };
+  await Promise.all(
+    [...urls].map(async ([url, file]) => {
+      let last = "";
+      for (let attempt = 0; attempt <= retries; attempt++) {
+        try {
+          const status = await probe(url);
+          if (status < 400) return;
+          last = `HTTP ${status}`;
+          if (status < 500 && status !== 429) break;
+        } catch (e) {
+          last = e.message;
+        }
+        await new Promise((r) => setTimeout(r, 1e3 * (attempt + 1)));
+      }
+      issues.push({ file, message: `broken URL ${url} (${last})` });
+    })
+  );
+  return issues;
+}
+function validateSkillsDir(root) {
+  const issues = [];
+  const urls = /* @__PURE__ */ new Map();
+  const folders = skillFolders(root);
+  const names = /* @__PURE__ */ new Set();
+  for (const folder of folders) {
+    const r = validateSkill((0, import_node_path3.join)(root, folder));
+    issues.push(...r.issues);
+    for (const [u, f] of r.urls) if (!urls.has(u)) urls.set(u, f);
+    if (names.has(folder))
+      issues.push({ file: folder, message: "duplicate skill name" });
+    names.add(folder);
+  }
+  if (folders.length === 0)
+    issues.push({ file: root, message: "no skill folders found" });
+  return { issues, urls, count: folders.length };
+}
+
+// src/cli.ts
+var HELP = `Channlize Agent Skills: teach AI coding agents to integrate Channlize.
+
+Usage:
+  npx @channlize/skills install [targets] [--project | --user] [options]
+  npx @channlize/skills list
+  npx @channlize/skills prompts [id] [--project-id <id>] [--widget-key <wk_\u2026>] [--category <c>] [--json]
+  npx @channlize/skills validate [skills-dir] [--marketplace <dir>] [--check-urls]
+
+Install targets (default: --claude):
+  --claude    .claude/skills     (Claude Code)
+  --cursor    .cursor/skills     (Cursor)
+  --codex     .agents/skills     (Codex; Cursor and VS Code read it too)
+  --copilot   .github/skills     (VS Code / GitHub Copilot)
+  --all       --claude, --codex and --copilot
+  --dir <path>  any other skills folder
+
+Install options:
+  --project         into the current directory (default)
+  --user            into your home directory (~/.claude/skills, ~/.agents/skills, ~/.copilot/skills\u2026)
+  --skill <name>    only this skill (repeatable)
+  --force           overwrite files you changed, without asking
+  --dry-run         show what would change
+  -y, --yes         same as --force
+
+Files you edited after installing are never replaced silently: the CLI asks
+in a terminal and keeps them otherwise (or use --force).`;
+var VALUE_FLAGS = /* @__PURE__ */ new Set([
+  "dir",
+  "skill",
+  "project-id",
+  "widget-key",
+  "category",
+  "marketplace",
+  "out"
+]);
+function parseArgs(argv) {
+  const args = { _: [], flags: /* @__PURE__ */ new Set(), values: {} };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === "-y") args.flags.add("yes");
+    else if (a === "-h") args.flags.add("help");
+    else if (a.startsWith("--")) {
+      const [key, inline] = a.slice(2).split(/=(.*)/s, 2);
+      if (VALUE_FLAGS.has(key)) {
+        const value = inline ?? argv[++i];
+        if (value === void 0) throw new UsageError(`--${key} needs a value`);
+        (args.values[key] ??= []).push(value);
+      } else args.flags.add(key);
+    } else args._.push(a);
+  }
+  return args;
+}
+var UsageError = class extends Error {
+};
+var out = (s = "") => process.stdout.write(s + "\n");
+var err = (s) => process.stderr.write(s + "\n");
+function printIssues(issues) {
+  for (const i of issues) err(`  \u2717 ${i.file}: ${i.message}`);
+}
+async function install(args) {
+  const known = /* @__PURE__ */ new Set([
+    ...TARGET_IDS,
+    "all",
+    "project",
+    "user",
+    "force",
+    "yes",
+    "dry-run"
+  ]);
+  for (const f of args.flags)
+    if (!known.has(f)) throw new UsageError(`unknown option --${f}`);
+  if (args.flags.has("project") && args.flags.has("user"))
+    throw new UsageError("use --project or --user, not both");
+  const scope = args.flags.has("user") ? "user" : "project";
+  let targets = args.flags.has("all") ? [...ALL_TARGETS] : TARGET_IDS.filter((t) => args.flags.has(t));
+  const dirs = [];
+  for (const d of args.values.dir ?? [])
+    dirs.push({ label: "custom", dir: (0, import_node_path4.resolve)(d) });
+  if (targets.length === 0 && dirs.length === 0) targets = ["claude"];
+  for (const t of targets)
+    dirs.push({ label: TARGETS[t].label, dir: targetDir(t, scope) });
+  const all = loadSkills();
+  const wanted = args.values.skill ?? [];
+  for (const w of wanted) {
+    if (!all.some((s) => s.name === w))
+      throw new UsageError(
+        `unknown skill "${w}" (see: npx @channlize/skills list)`
+      );
+  }
+  const skills = wanted.length ? all.filter((s) => wanted.includes(s.name)) : all;
+  const force = args.flags.has("force") || args.flags.has("yes");
+  const dryRun = args.flags.has("dry-run");
+  const interactive = process.stdin.isTTY && process.stdout.isTTY && !force && !dryRun;
+  const rl = interactive ? (0, import_promises.createInterface)({ input: process.stdin, output: process.stdout }) : null;
+  let overwriteAll = false;
+  const confirm = rl ? async (f) => {
+    if (overwriteAll) return true;
+    const answer = (await rl.question(
+      `  ${shown(f.dest)} was changed since it was installed. Overwrite? [y/N/a(ll)] `
+    )).trim().toLowerCase();
+    if (answer === "a" || answer === "all") overwriteAll = true;
+    return answer === "y" || answer === "yes" || overwriteAll;
+  } : void 0;
+  let kept = 0;
+  try {
+    for (const { label, dir } of dirs) {
+      out(`${dryRun ? "[dry run] " : ""}${label}: ${shown(dir)}`);
+      const results = await installSkills({
+        skills,
+        dir,
+        version: packageVersion(),
+        force,
+        dryRun,
+        confirm
+      });
+      for (const r of results) {
+        if (r.action === "unchanged") continue;
+        out(
+          `  ${symbol[r.action]} ${r.skill}/${r.path}${r.action === "kept" ? "  (kept your changes)" : ""}`
+        );
+      }
+      const n = (a) => results.filter((r) => r.action === a).length;
+      kept += n("kept");
+      out(
+        `  ${skills.length} skills: ${n("created")} created, ${n("updated") + n("overwritten")} updated, ${n("unchanged")} unchanged, ${n("kept")} kept`
+      );
+    }
+  } finally {
+    rl?.close();
+  }
+  if (kept > 0)
+    out(
+      `
+${kept} file(s) you edited were kept. Re-run with --force to replace them.`
+    );
+  if (!dryRun) {
+    out(
+      `
+Done. Start a new agent session so it picks up the skills, then ask it, for example:`
+    );
+    out(`  "Add the Channlize chat widget to this app"`);
+    out(`Prompts to copy: npx @channlize/skills prompts`);
+  }
+  return 0;
+}
+var symbol = {
+  created: "+",
+  updated: "~",
+  overwritten: "!",
+  unchanged: "=",
+  kept: "\xB7"
+};
+function shown(p) {
+  const rel = (0, import_node_path4.relative)(process.cwd(), p);
+  return rel && !rel.startsWith("..") ? rel : p;
+}
+function list() {
+  for (const s of loadSkills()) {
+    out(s.name);
+    out(`  ${s.description}`);
+  }
+  return 0;
+}
+function prompts(args) {
+  const lib = loadPrompts();
+  const category = args.values.category?.[0];
+  if (category && !lib.categories[category]) {
+    throw new UsageError(
+      `unknown category "${category}" (${Object.keys(lib.categories).join(", ")})`
+    );
+  }
+  const id = args._[1];
+  let entries = lib.prompts.filter((p) => !category || p.category === category);
+  if (id) {
+    entries = entries.filter((p) => p.id === id);
+    if (entries.length === 0) throw new UsageError(`unknown prompt "${id}"`);
+  }
+  const values = {
+    projectId: args.values["project-id"]?.[0],
+    widgetKey: args.values["widget-key"]?.[0]
+  };
+  if (values.widgetKey && !values.widgetKey.startsWith("wk_")) {
+    throw new UsageError(
+      "--widget-key takes the public widget key (wk_\u2026). Server keys never go in a prompt."
+    );
+  }
+  const filled = entries.map((p) => ({
+    ...p,
+    prompt: fillPrompt(p.prompt, lib, values)
+  }));
+  if (args.flags.has("json")) {
+    out(JSON.stringify(filled, null, 2));
+    return 0;
+  }
+  if (!id) {
+    for (const p of filled)
+      out(`${p.id.padEnd(26)} ${lib.categories[p.category]} \xB7 ${p.title}`);
+    out(
+      `
+Print one: npx @channlize/skills prompts <id> --project-id <id> --widget-key <wk_\u2026>`
+    );
+    return 0;
+  }
+  out(filled[0].prompt);
+  return 0;
+}
+async function validate(args) {
+  const dir = (0, import_node_path4.resolve)(args._[1] ?? bundledSkillsDir());
+  const { issues, urls, count } = validateSkillsDir(dir);
+  const isBundled = dir === (0, import_node_path4.resolve)(bundledSkillsDir());
+  if (isBundled) {
+    const names = loadSkills(dir).map((s) => s.name);
+    issues.push(...validatePrompts(loadPrompts(), names, "prompts.json"));
+  }
+  for (const m of args.values.marketplace ?? [])
+    issues.push(...validateMarketplace((0, import_node_path4.resolve)(m)));
+  if (args.flags.has("check-urls")) issues.push(...await checkUrls(urls));
+  if (issues.length) {
+    err(`\u2717 ${issues.length} problem(s) in ${shown(dir)}:`);
+    printIssues(issues);
+    return 1;
+  }
+  out(
+    `\u2713 ${count} skills valid in ${shown(dir)}${args.flags.has("check-urls") ? `, ${urls.size} URLs reachable` : ""}`
+  );
+  return 0;
+}
+function catalog(args) {
+  const json = JSON.stringify(buildCatalog(), null, 2) + "\n";
+  const file = args.values.out?.[0];
+  if (file) (0, import_node_fs4.writeFileSync)((0, import_node_path4.resolve)(file), json);
+  else process.stdout.write(json);
+  return 0;
+}
+async function main(argv) {
+  try {
+    const args = parseArgs(argv);
+    if (args.flags.has("version")) {
+      out(packageVersion());
+      return 0;
+    }
+    const command = args._[0];
+    if (!command || args.flags.has("help") || command === "help") {
+      out(HELP);
+      return command || args.flags.has("help") ? 0 : 1;
+    }
+    switch (command) {
+      case "install":
+        return await install(args);
+      case "list":
+        return list();
+      case "prompts":
+        return prompts(args);
+      case "validate":
+        return await validate(args);
+      case "catalog":
+        return catalog(args);
+      case "path":
+        out((0, import_node_path4.join)(packageRoot(), "skills"));
+        return 0;
+      default:
+        throw new UsageError(`unknown command "${command}"`);
+    }
+  } catch (e) {
+    if (e instanceof UsageError) {
+      err(`error: ${e.message}
+Run npx @channlize/skills --help for usage.`);
+      return 2;
+    }
+    throw e;
+  }
+}
+if (require.main === module) {
+  process.stdout.on("error", (e) => {
+    if (e.code === "EPIPE") process.exit(0);
+    throw e;
+  });
+  main(process.argv.slice(2)).then(
+    (code) => process.exit(code),
+    (e) => {
+      err(String(e?.stack ?? e));
+      process.exit(1);
+    }
+  );
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  main,
+  parseArgs
+});
+//# sourceMappingURL=cli.js.map