@runecraft/grimoire 1.0.0

package/dist/grimoire.js

@@ -0,0 +1,1758 @@
+#!/usr/bin/env node
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
+var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  if (mod && typeof mod === "object" || typeof mod === "function") {
+    for (let key of __getOwnPropNames(mod))
+      if (!__hasOwnProp.call(to, key))
+        __defProp(to, key, {
+          get: __accessProp.bind(mod, key),
+          enumerable: true
+        });
+  }
+  if (canCache)
+    cache.set(mod, to);
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+
+// ../../node_modules/.bun/sisteransi@1.0.5/node_modules/sisteransi/src/index.js
+var require_src = __commonJS(function(exports, module) {
+  var ESC2 = "\x1B";
+  var CSI2 = `${ESC2}[`;
+  var beep = "\x07";
+  var cursor = {
+    to(x, y) {
+      if (!y)
+        return `${CSI2}${x + 1}G`;
+      return `${CSI2}${y + 1};${x + 1}H`;
+    },
+    move(x, y) {
+      let ret = "";
+      if (x < 0)
+        ret += `${CSI2}${-x}D`;
+      else if (x > 0)
+        ret += `${CSI2}${x}C`;
+      if (y < 0)
+        ret += `${CSI2}${-y}A`;
+      else if (y > 0)
+        ret += `${CSI2}${y}B`;
+      return ret;
+    },
+    up: (count = 1) => `${CSI2}${count}A`,
+    down: (count = 1) => `${CSI2}${count}B`,
+    forward: (count = 1) => `${CSI2}${count}C`,
+    backward: (count = 1) => `${CSI2}${count}D`,
+    nextLine: (count = 1) => `${CSI2}E`.repeat(count),
+    prevLine: (count = 1) => `${CSI2}F`.repeat(count),
+    left: `${CSI2}G`,
+    hide: `${CSI2}?25l`,
+    show: `${CSI2}?25h`,
+    save: `${ESC2}7`,
+    restore: `${ESC2}8`
+  };
+  var scroll = {
+    up: (count = 1) => `${CSI2}S`.repeat(count),
+    down: (count = 1) => `${CSI2}T`.repeat(count)
+  };
+  var erase = {
+    screen: `${CSI2}2J`,
+    up: (count = 1) => `${CSI2}1J`.repeat(count),
+    down: (count = 1) => `${CSI2}J`.repeat(count),
+    line: `${CSI2}2K`,
+    lineEnd: `${CSI2}K`,
+    lineStart: `${CSI2}1K`,
+    lines(count) {
+      let clear = "";
+      for (let i = 0;i < count; i++)
+        clear += this.line + (i < count - 1 ? cursor.up() : "");
+      if (count)
+        clear += cursor.left;
+      return clear;
+    }
+  };
+  module.exports = { cursor, scroll, erase, beep };
+});
+
+// src/index.ts
+import { existsSync as existsSync5, readFileSync as readFileSync5 } from "node:fs";
+import { homedir as homedir2 } from "node:os";
+import { resolve as resolve4, join as join7 } from "node:path";
+import { fileURLToPath } from "node:url";
+
+// src/detect.ts
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+var rules = [
+  ["Next.js", ["next"], ["next.config.js", "next.config.mjs"], [{ name: "code-review-and-quality", reason: "Next.js projects benefit from consistent review and quality checks." }]],
+  ["React", ["react", "react-dom"], ["vite.config.ts", "vite.config.js"], [{ name: "typescript-patterns", reason: "Typed UI projects benefit from reusable TypeScript patterns." }]],
+  ["TypeScript", ["typescript"], ["tsconfig.json"], [{ name: "typescript-patterns", reason: "A TypeScript configuration was detected." }]],
+  ["Git", [], [".gitignore"], [{ name: "git-worktree", reason: "Git projects can use safer isolated worktrees." }]]
+];
+function detectStack(projectDir, catalog) {
+  let packages = {};
+  try {
+    const pkg = JSON.parse(readFileSync(join(projectDir, "package.json"), "utf8"));
+    packages = { ...pkg.dependencies, ...pkg.devDependencies };
+  } catch {}
+  const stack = [];
+  const recommendations = [];
+  for (const [name, deps, files, suggested] of rules)
+    if (deps.some((dep) => (dep in packages)) || files.some((file) => existsSync(join(projectDir, file)))) {
+      stack.push(name);
+      recommendations.push(...suggested);
+    }
+  const available = catalog ? new Set(catalog.map((s) => s.name)) : undefined;
+  const unique = recommendations.filter((r, i, all) => (!available || available.has(r.name)) && all.findIndex((x) => x.name === r.name) === i);
+  return { stack, recommendations: unique, skills: unique.map((r) => r.name) };
+}
+
+// src/install.ts
+import { createHash } from "node:crypto";
+import { cpSync, existsSync as existsSync2, lstatSync, mkdirSync, readdirSync, readFileSync as readFileSync2, realpathSync, rmSync } from "node:fs";
+import { join as join3, relative, resolve as resolve2, sep } from "node:path";
+
+// src/agents.ts
+import { isAbsolute, join as join2, resolve } from "node:path";
+function safeSkillName(name) {
+  return name.length > 0 && name !== "." && name !== ".." && !isAbsolute(name) && !name.includes("/") && !name.includes("\\");
+}
+
+// src/install.ts
+function assertNoSymlinks(path) {
+  const absolute = resolve2(path);
+  let current = absolute.startsWith(sep) ? sep : "";
+  for (const part of absolute.slice(current.length).split(sep).filter(Boolean)) {
+    current = join3(current, part);
+    if (lstatSync(current, { throwIfNoEntry: false })?.isSymbolicLink())
+      throw new Error("target path cannot contain symlinks");
+  }
+}
+function assertTarget(dir) {
+  const target = resolve2(dir);
+  assertNoSymlinks(target);
+  mkdirSync(target, { recursive: true });
+  if (realpathSync(target) !== target)
+    throw new Error("target path cannot contain symlinks");
+  return target;
+}
+function assertCatalog(dir, name) {
+  if (!lstatSync(dir, { throwIfNoEntry: false })?.isDirectory())
+    throw new Error(`invalid catalog entry: ${name}`);
+  for (const e of readdirSync(dir, { withFileTypes: true })) {
+    if (e.isSymbolicLink())
+      throw new Error(`catalog skill cannot contain symlinks: ${name}`);
+    if (e.isDirectory())
+      assertCatalog(join3(dir, e.name), name);
+  }
+}
+function skillHash(dir) {
+  const hash = createHash("sha256");
+  const walk = (current) => {
+    for (const e of readdirSync(current, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
+      const path = join3(current, e.name);
+      if (e.isDirectory())
+        walk(path);
+      else {
+        hash.update(relative(dir, path));
+        hash.update(readFileSync2(path));
+      }
+    }
+  };
+  walk(dir);
+  return `sha256:${hash.digest("hex")}`;
+}
+function findConflicts(targetDir, names) {
+  return names.filter((name) => existsSync2(join3(targetDir, name)));
+}
+function installSkills(opts) {
+  const result = { installed: [], overwritten: [], skipped: [], failed: [] };
+  const target = assertTarget(opts.targetDir);
+  for (const name of opts.names) {
+    opts.onStatus?.(name);
+    try {
+      if (!safeSkillName(name))
+        throw new Error(`unsafe skill name: ${name}`);
+      const src = join3(opts.catalogDir, name);
+      if (!lstatSync(src, { throwIfNoEntry: false })?.isDirectory())
+        throw new Error(`not found in catalog: ${name}`);
+      assertCatalog(src, name);
+      const dest = resolve2(target, name);
+      if (!dest.startsWith(target + sep))
+        throw new Error("skill destination escapes target directory");
+      if (lstatSync(dest, { throwIfNoEntry: false })?.isSymbolicLink())
+        throw new Error("skill destination cannot be a symlink");
+      const exists = existsSync2(dest);
+      if (exists && !lstatSync(dest).isDirectory())
+        throw new Error("skill destination must be a directory");
+      if (exists && !opts.overwrite) {
+        result.skipped.push(name);
+        continue;
+      }
+      if (exists)
+        rmSync(dest, { recursive: true, force: true });
+      cpSync(src, dest, { recursive: true });
+      (exists ? result.overwritten : result.installed).push(name);
+    } catch (error) {
+      result.failed.push({ name, error: error instanceof Error ? error.message : String(error) });
+    }
+  }
+  return result;
+}
+
+// src/registry.ts
+import { existsSync as existsSync3, readdirSync as readdirSync2, readFileSync as readFileSync3 } from "node:fs";
+import { join as join4 } from "node:path";
+function frontmatter(raw) {
+  const body = /^---\r?\n([\s\S]*?)\r?\n---/.exec(raw)?.[1] ?? "";
+  const value = (key) => body.match(new RegExp(`^${key}:\\s*(.+)$`, "m"))?.[1].trim().replace(/^['"]|['"]$/g, "");
+  const description = body.match(/^description:\s*>[+-]?\s*([\s\S]*?)(?=^\S|$)/m)?.[1]?.split(/\r?\n/).map((line) => line.trim()).filter(Boolean).join(" ");
+  return { name: value("name"), description: description ?? value("description") };
+}
+function categoryMap(catalogDir) {
+  try {
+    const raw = JSON.parse(readFileSync3(join4(catalogDir, "..", "catalog.json"), "utf8"));
+    const map = new Map;
+    for (const [category, names] of Object.entries(raw.categories ?? {}))
+      for (const name of names)
+        map.set(name, category);
+    return map;
+  } catch {
+    return new Map;
+  }
+}
+function readRegistry(catalogDir) {
+  if (!existsSync3(catalogDir))
+    return [];
+  const categories = categoryMap(catalogDir);
+  return readdirSync2(catalogDir, { withFileTypes: true }).filter((e) => e.isDirectory() && existsSync3(join4(catalogDir, e.name, "SKILL.md"))).map((e) => {
+    const dir = join4(catalogDir, e.name);
+    let meta = {};
+    try {
+      meta = JSON.parse(readFileSync3(join4(dir, ".skill-meta.json"), "utf8"));
+    } catch {}
+    const front = frontmatter(readFileSync3(join4(dir, "SKILL.md"), "utf8"));
+    return { name: meta.name ?? front.name ?? e.name, description: meta.description ?? front.description ?? "", version: meta.version ?? "0.1.0", dir, category: categories.get(e.name) ?? "Other" };
+  }).sort((a, b) => a.name.localeCompare(b.name));
+}
+var listSkills = readRegistry;
+function categories(registry) {
+  const grouped = new Map;
+  for (const skill of registry) {
+    const category = skill.category ?? "Other";
+    grouped.set(category, [...grouped.get(category) ?? [], skill]);
+  }
+  return [...grouped].sort(([a], [b]) => a.localeCompare(b)).map(([name, skills]) => ({ name, skills }));
+}
+function findSkill(catalogDir, name) {
+  return readRegistry(catalogDir).find((skill) => skill.name === name);
+}
+
+// src/lockfile.ts
+import { existsSync as existsSync4, lstatSync as lstatSync2, readFileSync as readFileSync4, writeFileSync } from "node:fs";
+import { join as join5 } from "node:path";
+function lockPath(projectDir) {
+  return join5(projectDir, ".grimoire-lock.json");
+}
+function assertLockfilePath(projectDir) {
+  const path = lockPath(projectDir);
+  if (lstatSync2(path, { throwIfNoEntry: false })?.isSymbolicLink())
+    throw new Error("lockfile cannot be a symlink");
+  return path;
+}
+function readLockfile(projectDir) {
+  const path = assertLockfilePath(projectDir);
+  try {
+    const lock = JSON.parse(readFileSync4(path, "utf8"));
+    if (lock.version === 1 && lock.skills)
+      return lock;
+  } catch {}
+  return { version: 1, generated: new Date().toISOString(), registry: "runecraftai/grimoire", skills: {} };
+}
+function writeLockfile(projectDir, lock) {
+  writeFileSync(assertLockfilePath(projectDir), `${JSON.stringify(lock, null, 2)}
+`);
+}
+function updateLock(lock, name, entry) {
+  const existing = lock.skills[name];
+  lock.generated = new Date().toISOString();
+  lock.skills[name] = existing ? { ...entry, agents: [...new Set([...existing.agents, ...entry.agents])] } : entry;
+  return lock;
+}
+
+// src/targets.ts
+import { homedir } from "node:os";
+import { join as join6 } from "node:path";
+var TARGETS = [
+  { id: "pi", label: "pi", description: "pi coding agent — ~/.pi/agent/skills" },
+  { id: "claude", label: "Claude Code", description: "~/.claude/skills" },
+  { id: "codex", label: "Codex CLI", description: "~/.codex/skills" },
+  { id: "opencode", label: "OpenCode", description: "~/.config/opencode/skills" }
+];
+function isTargetId(value) {
+  return TARGETS.some((t) => t.id === value);
+}
+function resolveSkillsDir(id, ctx = {}) {
+  const home = ctx.home ?? homedir();
+  const env = ctx.env ?? process.env;
+  if (ctx.global === false) {
+    const projectPaths = { pi: ".pi/skills", claude: ".claude/skills", codex: ".codex/skills", opencode: ".opencode/skills" };
+    return join6(ctx.projectDir ?? process.cwd(), projectPaths[id]);
+  }
+  switch (id) {
+    case "pi":
+      return join6(env.PI_HOME ?? join6(home, ".pi"), "agent", "skills");
+    case "claude":
+      return join6(env.CLAUDE_CONFIG_DIR ?? join6(home, ".claude"), "skills");
+    case "codex":
+      return join6(env.CODEX_HOME ?? join6(home, ".codex"), "skills");
+    case "opencode": {
+      const xdg = env.XDG_CONFIG_HOME ?? join6(home, ".config");
+      return join6(xdg, "opencode", "skills");
+    }
+  }
+}
+function displayPath(path, home = homedir()) {
+  const root = home.replace(/\/+$/, "");
+  if (path === root)
+    return "~";
+  if (path.startsWith(root + "/"))
+    return "~" + path.slice(root.length);
+  return path;
+}
+
+// ../../node_modules/.bun/@clack+core@1.4.3/node_modules/@clack/core/dist/index.mjs
+import { styleText } from "node:util";
+import { stdout, stdin } from "node:process";
+import * as l from "node:readline";
+import l__default from "node:readline";
+
+// ../../node_modules/.bun/fast-string-truncated-width@3.0.3/node_modules/fast-string-truncated-width/dist/utils.js
+var getCodePointsLength = (() => {
+  const SURROGATE_PAIR_RE = /[\uD800-\uDBFF][\uDC00-\uDFFF]/g;
+  return (input) => {
+    let surrogatePairsNr = 0;
+    SURROGATE_PAIR_RE.lastIndex = 0;
+    while (SURROGATE_PAIR_RE.test(input)) {
+      surrogatePairsNr += 1;
+    }
+    return input.length - surrogatePairsNr;
+  };
+})();
+var isFullWidth = (x) => {
+  return x === 12288 || x >= 65281 && x <= 65376 || x >= 65504 && x <= 65510;
+};
+var isWideNotCJKTNotEmoji = (x) => {
+  return x === 8987 || x === 9001 || x >= 12272 && x <= 12287 || x >= 12289 && x <= 12350 || x >= 12441 && x <= 12543 || x >= 12549 && x <= 12591 || x >= 12593 && x <= 12686 || x >= 12688 && x <= 12771 || x >= 12783 && x <= 12830 || x >= 12832 && x <= 12871 || x >= 12880 && x <= 19903 || x >= 65040 && x <= 65049 || x >= 65072 && x <= 65106 || x >= 65108 && x <= 65126 || x >= 65128 && x <= 65131 || x >= 127488 && x <= 127490 || x >= 127504 && x <= 127547 || x >= 127552 && x <= 127560 || x >= 131072 && x <= 196605 || x >= 196608 && x <= 262141;
+};
+
+// ../../node_modules/.bun/fast-string-truncated-width@3.0.3/node_modules/fast-string-truncated-width/dist/index.js
+var ANSI_RE = /[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]|\u001b\]8;[^;]*;.*?(?:\u0007|\u001b\u005c)/y;
+var CONTROL_RE = /[\x00-\x08\x0A-\x1F\x7F-\x9F]{1,1000}/y;
+var CJKT_WIDE_RE = /(?:(?![\uFF61-\uFF9F\uFF00-\uFFEF])[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}\p{Script=Hangul}\p{Script=Tangut}]){1,1000}/yu;
+var TAB_RE = /\t{1,1000}/y;
+var EMOJI_RE = /[\u{1F1E6}-\u{1F1FF}]{2}|\u{1F3F4}[\u{E0061}-\u{E007A}]{2}[\u{E0030}-\u{E0039}\u{E0061}-\u{E007A}]{1,3}\u{E007F}|(?:\p{Emoji}\uFE0F\u20E3?|\p{Emoji_Modifier_Base}\p{Emoji_Modifier}?|\p{Emoji_Presentation})(?:\u200D(?:\p{Emoji_Modifier_Base}\p{Emoji_Modifier}?|\p{Emoji_Presentation}|\p{Emoji}\uFE0F\u20E3?))*/yu;
+var LATIN_RE = /(?:[\x20-\x7E\xA0-\xFF](?!\uFE0F)){1,1000}/y;
+var MODIFIER_RE = /\p{M}+/gu;
+var NO_TRUNCATION = { limit: Infinity, ellipsis: "" };
+var getStringTruncatedWidth = (input, truncationOptions = {}, widthOptions = {}) => {
+  const LIMIT = truncationOptions.limit ?? Infinity;
+  const ELLIPSIS = truncationOptions.ellipsis ?? "";
+  const ELLIPSIS_WIDTH = truncationOptions?.ellipsisWidth ?? (ELLIPSIS ? getStringTruncatedWidth(ELLIPSIS, NO_TRUNCATION, widthOptions).width : 0);
+  const ANSI_WIDTH = 0;
+  const CONTROL_WIDTH = widthOptions.controlWidth ?? 0;
+  const TAB_WIDTH = widthOptions.tabWidth ?? 8;
+  const EMOJI_WIDTH = widthOptions.emojiWidth ?? 2;
+  const FULL_WIDTH_WIDTH = 2;
+  const REGULAR_WIDTH = widthOptions.regularWidth ?? 1;
+  const WIDE_WIDTH = widthOptions.wideWidth ?? FULL_WIDTH_WIDTH;
+  const PARSE_BLOCKS = [
+    [LATIN_RE, REGULAR_WIDTH],
+    [ANSI_RE, ANSI_WIDTH],
+    [CONTROL_RE, CONTROL_WIDTH],
+    [TAB_RE, TAB_WIDTH],
+    [EMOJI_RE, EMOJI_WIDTH],
+    [CJKT_WIDE_RE, WIDE_WIDTH]
+  ];
+  let indexPrev = 0;
+  let index = 0;
+  let length = input.length;
+  let lengthExtra = 0;
+  let truncationEnabled = false;
+  let truncationIndex = length;
+  let truncationLimit = Math.max(0, LIMIT - ELLIPSIS_WIDTH);
+  let unmatchedStart = 0;
+  let unmatchedEnd = 0;
+  let width = 0;
+  let widthExtra = 0;
+  outer:
+    while (true) {
+      if (unmatchedEnd > unmatchedStart || index >= length && index > indexPrev) {
+        const unmatched = input.slice(unmatchedStart, unmatchedEnd) || input.slice(indexPrev, index);
+        lengthExtra = 0;
+        for (const char of unmatched.replaceAll(MODIFIER_RE, "")) {
+          const codePoint = char.codePointAt(0) || 0;
+          if (isFullWidth(codePoint)) {
+            widthExtra = FULL_WIDTH_WIDTH;
+          } else if (isWideNotCJKTNotEmoji(codePoint)) {
+            widthExtra = WIDE_WIDTH;
+          } else {
+            widthExtra = REGULAR_WIDTH;
+          }
+          if (width + widthExtra > truncationLimit) {
+            truncationIndex = Math.min(truncationIndex, Math.max(unmatchedStart, indexPrev) + lengthExtra);
+          }
+          if (width + widthExtra > LIMIT) {
+            truncationEnabled = true;
+            break outer;
+          }
+          lengthExtra += char.length;
+          width += widthExtra;
+        }
+        unmatchedStart = unmatchedEnd = 0;
+      }
+      if (index >= length) {
+        break outer;
+      }
+      for (let i = 0, l = PARSE_BLOCKS.length;i < l; i++) {
+        const [BLOCK_RE, BLOCK_WIDTH] = PARSE_BLOCKS[i];
+        BLOCK_RE.lastIndex = index;
+        if (BLOCK_RE.test(input)) {
+          lengthExtra = BLOCK_RE === CJKT_WIDE_RE ? getCodePointsLength(input.slice(index, BLOCK_RE.lastIndex)) : BLOCK_RE === EMOJI_RE ? 1 : BLOCK_RE.lastIndex - index;
+          widthExtra = lengthExtra * BLOCK_WIDTH;
+          if (width + widthExtra > truncationLimit) {
+            truncationIndex = Math.min(truncationIndex, index + Math.floor((truncationLimit - width) / BLOCK_WIDTH));
+          }
+          if (width + widthExtra > LIMIT) {
+            truncationEnabled = true;
+            break outer;
+          }
+          width += widthExtra;
+          unmatchedStart = indexPrev;
+          unmatchedEnd = index;
+          index = indexPrev = BLOCK_RE.lastIndex;
+          continue outer;
+        }
+      }
+      index += 1;
+    }
+  return {
+    width: truncationEnabled ? truncationLimit : width,
+    index: truncationEnabled ? truncationIndex : length,
+    truncated: truncationEnabled,
+    ellipsed: truncationEnabled && LIMIT >= ELLIPSIS_WIDTH
+  };
+};
+var dist_default = getStringTruncatedWidth;
+
+// ../../node_modules/.bun/fast-string-width@3.0.2/node_modules/fast-string-width/dist/index.js
+var NO_TRUNCATION2 = {
+  limit: Infinity,
+  ellipsis: "",
+  ellipsisWidth: 0
+};
+var fastStringWidth = (input, options = {}) => {
+  return dist_default(input, NO_TRUNCATION2, options).width;
+};
+var dist_default2 = fastStringWidth;
+
+// ../../node_modules/.bun/fast-wrap-ansi@0.2.2/node_modules/fast-wrap-ansi/lib/main.js
+var ESC = "\x1B";
+var CSI = "›";
+var END_CODE = 39;
+var ANSI_ESCAPE_BELL = "\x07";
+var ANSI_CSI = "[";
+var ANSI_OSC = "]";
+var ANSI_SGR_TERMINATOR = "m";
+var ANSI_ESCAPE_LINK = `${ANSI_OSC}8;;`;
+var GROUP_REGEX = new RegExp(`(?:\\${ANSI_CSI}(?<code>\\d+)m|\\${ANSI_ESCAPE_LINK}(?<uri>.*)${ANSI_ESCAPE_BELL})`, "y");
+var getClosingCode = (openingCode) => {
+  if (openingCode >= 30 && openingCode <= 37)
+    return 39;
+  if (openingCode >= 90 && openingCode <= 97)
+    return 39;
+  if (openingCode >= 40 && openingCode <= 47)
+    return 49;
+  if (openingCode >= 100 && openingCode <= 107)
+    return 49;
+  if (openingCode === 1 || openingCode === 2)
+    return 22;
+  if (openingCode === 3)
+    return 23;
+  if (openingCode === 4)
+    return 24;
+  if (openingCode === 7)
+    return 27;
+  if (openingCode === 8)
+    return 28;
+  if (openingCode === 9)
+    return 29;
+  if (openingCode === 0)
+    return 0;
+  return;
+};
+var wrapAnsiCode = (code) => `${ESC}${ANSI_CSI}${code}${ANSI_SGR_TERMINATOR}`;
+var wrapAnsiHyperlink = (url) => `${ESC}${ANSI_ESCAPE_LINK}${url}${ANSI_ESCAPE_BELL}`;
+var wrapWord = (rows, word, columns) => {
+  const characters = word[Symbol.iterator]();
+  let isInsideEscape = false;
+  let isInsideLinkEscape = false;
+  let lastRow = rows.at(-1);
+  let visible = lastRow === undefined ? 0 : dist_default2(lastRow);
+  let currentCharacter = characters.next();
+  let nextCharacter = characters.next();
+  let rawCharacterIndex = 0;
+  while (!currentCharacter.done) {
+    const character = currentCharacter.value;
+    const characterLength = dist_default2(character);
+    if (visible + characterLength <= columns) {
+      rows[rows.length - 1] += character;
+    } else {
+      rows.push(character);
+      visible = 0;
+    }
+    if (character === ESC || character === CSI) {
+      isInsideEscape = true;
+      isInsideLinkEscape = word.startsWith(ANSI_ESCAPE_LINK, rawCharacterIndex + 1);
+    }
+    if (isInsideEscape) {
+      if (isInsideLinkEscape) {
+        if (character === ANSI_ESCAPE_BELL) {
+          isInsideEscape = false;
+          isInsideLinkEscape = false;
+        }
+      } else if (character === ANSI_SGR_TERMINATOR) {
+        isInsideEscape = false;
+      }
+    } else {
+      visible += characterLength;
+      if (visible === columns && !nextCharacter.done) {
+        rows.push("");
+        visible = 0;
+      }
+    }
+    currentCharacter = nextCharacter;
+    nextCharacter = characters.next();
+    rawCharacterIndex += character.length;
+  }
+  lastRow = rows.at(-1);
+  if (!visible && lastRow !== undefined && lastRow.length && rows.length > 1) {
+    rows[rows.length - 2] += rows.pop();
+  }
+};
+var stringVisibleTrimSpacesRight = (string) => {
+  const words = string.split(" ");
+  let last = words.length;
+  while (last) {
+    if (dist_default2(words[last - 1])) {
+      break;
+    }
+    last--;
+  }
+  if (last === words.length) {
+    return string;
+  }
+  return words.slice(0, last).join(" ") + words.slice(last).join("");
+};
+var exec = (string, columns, options = {}) => {
+  if (options.trim !== false && string.trim() === "") {
+    return "";
+  }
+  let returnValue = "";
+  let escapeCode;
+  let escapeUrl;
+  const words = string.split(" ");
+  let rows = [""];
+  let rowLength = 0;
+  for (let index = 0;index < words.length; index++) {
+    const word = words[index];
+    if (options.trim !== false) {
+      const row = rows.at(-1) ?? "";
+      const trimmed = row.trimStart();
+      if (row.length !== trimmed.length) {
+        rows[rows.length - 1] = trimmed;
+        rowLength = dist_default2(trimmed);
+      }
+    }
+    if (index !== 0) {
+      if (rowLength >= columns && (options.wordWrap === false || options.trim === false)) {
+        rows.push("");
+        rowLength = 0;
+      }
+      if (rowLength || options.trim === false) {
+        rows[rows.length - 1] += " ";
+        rowLength++;
+      }
+    }
+    const wordLength = dist_default2(word);
+    if (options.hard && wordLength > columns) {
+      const remainingColumns = columns - rowLength;
+      const breaksStartingThisLine = 1 + Math.floor((wordLength - remainingColumns - 1) / columns);
+      const breaksStartingNextLine = Math.floor((wordLength - 1) / columns);
+      if (breaksStartingNextLine < breaksStartingThisLine) {
+        rows.push("");
+      }
+      wrapWord(rows, word, columns);
+      rowLength = dist_default2(rows.at(-1) ?? "");
+      continue;
+    }
+    if (rowLength + wordLength > columns && rowLength && wordLength) {
+      if (options.wordWrap === false && rowLength < columns) {
+        wrapWord(rows, word, columns);
+        rowLength = dist_default2(rows.at(-1) ?? "");
+        continue;
+      }
+      rows.push("");
+      rowLength = 0;
+    }
+    if (rowLength + wordLength > columns && options.wordWrap === false) {
+      wrapWord(rows, word, columns);
+      rowLength = dist_default2(rows.at(-1) ?? "");
+      continue;
+    }
+    rows[rows.length - 1] += word;
+    rowLength += wordLength;
+  }
+  if (options.trim !== false) {
+    rows = rows.map((row) => stringVisibleTrimSpacesRight(row));
+  }
+  const preString = rows.join(`
+`);
+  let inSurrogate = false;
+  for (let i = 0;i < preString.length; i++) {
+    const character = preString[i];
+    returnValue += character;
+    if (!inSurrogate) {
+      inSurrogate = character >= "\uD800" && character <= "\uDBFF";
+      if (inSurrogate) {
+        continue;
+      }
+    } else {
+      inSurrogate = false;
+    }
+    if (character === ESC || character === CSI) {
+      GROUP_REGEX.lastIndex = i + 1;
+      const groupsResult = GROUP_REGEX.exec(preString);
+      const groups = groupsResult?.groups;
+      if (groups?.code !== undefined) {
+        const code = Number.parseFloat(groups.code);
+        escapeCode = code === END_CODE ? undefined : code;
+      } else if (groups?.uri !== undefined) {
+        escapeUrl = groups.uri.length === 0 ? undefined : groups.uri;
+      }
+    }
+    if (preString[i + 1] === `
+`) {
+      if (escapeUrl) {
+        returnValue += wrapAnsiHyperlink("");
+      }
+      const closingCode = escapeCode ? getClosingCode(escapeCode) : undefined;
+      if (escapeCode && closingCode) {
+        returnValue += wrapAnsiCode(closingCode);
+      }
+    } else if (character === `
+`) {
+      if (escapeCode && getClosingCode(escapeCode)) {
+        returnValue += wrapAnsiCode(escapeCode);
+      }
+      if (escapeUrl) {
+        returnValue += wrapAnsiHyperlink(escapeUrl);
+      }
+    }
+  }
+  return returnValue;
+};
+var CRLF_OR_LF = /\r?\n/;
+function wrapAnsi(string, columns, options) {
+  return String(string).normalize().split(CRLF_OR_LF).map((line) => exec(line, columns, options)).join(`
+`);
+}
+
+// ../../node_modules/.bun/@clack+core@1.4.3/node_modules/@clack/core/dist/index.mjs
+var import_sisteransi = __toESM(require_src(), 1);
+import { ReadStream } from "node:tty";
+function findCursor(s, o, l2) {
+  if (!l2.some((r) => !r.disabled))
+    return s;
+  const t = s + o, n = Math.max(l2.length - 1, 0), e = t < 0 ? n : t > n ? 0 : t;
+  return l2[e]?.disabled ? findCursor(e, o < 0 ? -1 : 1, l2) : e;
+}
+var a$1 = ["up", "down", "left", "right", "space", "enter", "cancel"];
+var t = [
+  "January",
+  "February",
+  "March",
+  "April",
+  "May",
+  "June",
+  "July",
+  "August",
+  "September",
+  "October",
+  "November",
+  "December"
+];
+var settings = {
+  actions: new Set(a$1),
+  aliases: /* @__PURE__ */ new Map([
+    ["k", "up"],
+    ["j", "down"],
+    ["h", "left"],
+    ["l", "right"],
+    ["\x03", "cancel"],
+    ["escape", "cancel"]
+  ]),
+  messages: {
+    cancel: "Canceled",
+    error: "Something went wrong"
+  },
+  withGuide: true,
+  date: {
+    monthNames: [...t],
+    messages: {
+      required: "Please enter a valid date",
+      invalidMonth: "There are only 12 months in a year",
+      invalidDay: (n, e) => `There are only ${n} days in ${e}`,
+      afterMin: (n) => `Date must be on or after ${n.toISOString().slice(0, 10)}`,
+      beforeMax: (n) => `Date must be on or before ${n.toISOString().slice(0, 10)}`
+    }
+  }
+};
+function isActionKey(n, e) {
+  if (typeof n == "string")
+    return settings.aliases.get(n) === e;
+  for (const s of n)
+    if (s !== undefined && isActionKey(s, e))
+      return true;
+  return false;
+}
+function diffLines(i, s) {
+  if (i === s)
+    return;
+  const e = i.split(`
+`), t2 = s.split(`
+`), r = Math.max(e.length, t2.length), f = [];
+  for (let n = 0;n < r; n++)
+    e[n] !== t2[n] && f.push(n);
+  return {
+    lines: f,
+    numLinesBefore: e.length,
+    numLinesAfter: t2.length,
+    numLines: r
+  };
+}
+var R = globalThis.process.platform.startsWith("win");
+var CANCEL_SYMBOL = Symbol("clack:cancel");
+function isCancel(e) {
+  return e === CANCEL_SYMBOL;
+}
+function setRawMode(e, r) {
+  const o = e;
+  o.isTTY && o.setRawMode(r);
+}
+function block({
+  input: e = stdin,
+  output: r = stdout,
+  overwrite: o = true,
+  hideCursor: t2 = true
+} = {}) {
+  const s = l.createInterface({
+    input: e,
+    output: r,
+    prompt: "",
+    tabSize: 1
+  });
+  l.emitKeypressEvents(e, s), e instanceof ReadStream && e.isTTY && e.setRawMode(true);
+  const n = (f, { name: a, sequence: p }) => {
+    const c = String(f);
+    if (isActionKey([c, a, p], "cancel")) {
+      t2 && r.write(import_sisteransi.cursor.show), process.exit(0);
+      return;
+    }
+    if (!o)
+      return;
+    const i = a === "return" ? 0 : -1, m = a === "return" ? -1 : 0;
+    l.moveCursor(r, i, m, () => {
+      l.clearLine(r, 1, () => {
+        e.once("keypress", n);
+      });
+    });
+  };
+  return t2 && r.write(import_sisteransi.cursor.hide), e.once("keypress", n), () => {
+    e.off("keypress", n), t2 && r.write(import_sisteransi.cursor.show), e instanceof ReadStream && e.isTTY && !R && e.setRawMode(false), s.terminal = false, s.close();
+  };
+}
+var getColumns = (e) => ("columns" in e) && typeof e.columns == "number" ? e.columns : 80;
+var getRows = (e) => ("rows" in e) && typeof e.rows == "number" ? e.rows : 20;
+function wrapTextWithPrefix(e, r, o, t2 = o, s = o, n) {
+  const f = getColumns(e ?? stdout);
+  return wrapAnsi(r, f - o.length, {
+    hard: true,
+    trim: false
+  }).split(`
+`).map((c, i, m) => {
+    const d = n ? n(c, i) : c;
+    return i === 0 ? `${t2}${d}` : i === m.length - 1 ? `${s}${d}` : `${o}${d}`;
+  }).join(`
+`);
+}
+function runValidation(e, n) {
+  if ("~standard" in e) {
+    const a = e["~standard"].validate(n);
+    if (a instanceof Promise)
+      throw new TypeError("Schema validation must be synchronous. Update `validate()` and remove any asynchronous logic.");
+    return a.issues?.at(0)?.message;
+  }
+  return e(n);
+}
+
+class V {
+  input;
+  output;
+  _abortSignal;
+  rl;
+  opts;
+  _render;
+  _track = false;
+  _prevFrame = "";
+  _subscribers = /* @__PURE__ */ new Map;
+  _cursor = 0;
+  state = "initial";
+  error = "";
+  value;
+  userInput = "";
+  constructor(t2, e = true) {
+    const { input: i = stdin, output: n = stdout, render: s, signal: r, ...o } = t2;
+    this.opts = o, this.onKeypress = this.onKeypress.bind(this), this.close = this.close.bind(this), this.render = this.render.bind(this), this._render = s.bind(this), this._track = e, this._abortSignal = r, this.input = i, this.output = n;
+  }
+  unsubscribe() {
+    this._subscribers.clear();
+  }
+  setSubscriber(t2, e) {
+    const i = this._subscribers.get(t2) ?? [];
+    i.push(e), this._subscribers.set(t2, i);
+  }
+  on(t2, e) {
+    this.setSubscriber(t2, { cb: e });
+  }
+  once(t2, e) {
+    this.setSubscriber(t2, { cb: e, once: true });
+  }
+  emit(t2, ...e) {
+    const i = this._subscribers.get(t2) ?? [], n = [];
+    for (const s of i)
+      s.cb(...e), s.once && n.push(() => i.splice(i.indexOf(s), 1));
+    for (const s of n)
+      s();
+  }
+  prompt() {
+    return new Promise((t2) => {
+      if (this._abortSignal) {
+        if (this._abortSignal.aborted)
+          return this.state = "cancel", this.close(), t2(CANCEL_SYMBOL);
+        this._abortSignal.addEventListener("abort", () => {
+          this.state = "cancel", this.close();
+        }, { once: true });
+      }
+      this.rl = l__default.createInterface({
+        input: this.input,
+        tabSize: 2,
+        prompt: "",
+        escapeCodeTimeout: 50,
+        terminal: true
+      }), this.rl.prompt(), this.opts.initialUserInput !== undefined && this._setUserInput(this.opts.initialUserInput, true), this.input.on("keypress", this.onKeypress), setRawMode(this.input, true), this.output.on("resize", this.render), this.render(), this.once("submit", () => {
+        this.output.write(import_sisteransi.cursor.show), this.output.off("resize", this.render), setRawMode(this.input, false), t2(this.value);
+      }), this.once("cancel", () => {
+        this.output.write(import_sisteransi.cursor.show), this.output.off("resize", this.render), setRawMode(this.input, false), t2(CANCEL_SYMBOL);
+      });
+    });
+  }
+  _isActionKey(t2, e) {
+    return t2 === "\t";
+  }
+  _shouldSubmit(t2, e) {
+    return true;
+  }
+  _setValue(t2) {
+    this.value = t2, this.emit("value", this.value);
+  }
+  _setUserInput(t2, e) {
+    this.userInput = t2 ?? "", this.emit("userInput", this.userInput), e && this._track && this.rl && (this.rl.write(this.userInput), this._cursor = this.rl.cursor);
+  }
+  _clearUserInput() {
+    this.rl?.write(null, { ctrl: true, name: "u" }), this._setUserInput("");
+  }
+  onKeypress(t2, e) {
+    if (this._track && e.name !== "return" && (e.name && this._isActionKey(t2, e) && this.rl?.write(null, { ctrl: true, name: "h" }), this._cursor = this.rl?.cursor ?? 0, this._setUserInput(this.rl?.line)), this.state === "error" && (this.state = "active"), e?.name && (!this._track && settings.aliases.has(e.name) && this.emit("cursor", settings.aliases.get(e.name)), settings.actions.has(e.name) && this.emit("cursor", e.name)), t2 && (t2.toLowerCase() === "y" || t2.toLowerCase() === "n") && this.emit("confirm", t2.toLowerCase() === "y"), this.emit("key", t2, e), e?.name === "return" && this._shouldSubmit(t2, e)) {
+      if (this.opts.validate) {
+        const i = runValidation(this.opts.validate, this.value);
+        i && (this.error = i instanceof Error ? i.message : i, this.state = "error", this.rl?.write(this.userInput));
+      }
+      this.state !== "error" && (this.state = "submit");
+    }
+    isActionKey([t2, e?.name, e?.sequence], "cancel") && (this.state = "cancel"), (this.state === "submit" || this.state === "cancel") && this.emit("finalize"), this.render(), (this.state === "submit" || this.state === "cancel") && this.close();
+  }
+  close() {
+    this.input.unpipe(), this.input.removeListener("keypress", this.onKeypress), this.output.write(`
+`), setRawMode(this.input, false), this.rl?.close(), this.rl = undefined, this.emit(`${this.state}`, this.value), this.unsubscribe();
+  }
+  restoreCursor() {
+    const t2 = wrapAnsi(this._prevFrame, process.stdout.columns, { hard: true, trim: false }).split(`
+`).length - 1;
+    this.output.write(import_sisteransi.cursor.move(-999, t2 * -1));
+  }
+  render() {
+    const t2 = wrapAnsi(this._render(this) ?? "", process.stdout.columns, {
+      hard: true,
+      trim: false
+    });
+    if (t2 !== this._prevFrame) {
+      if (this.state === "initial")
+        this.output.write(import_sisteransi.cursor.hide);
+      else {
+        const e = diffLines(this._prevFrame, t2), i = getRows(this.output);
+        if (this.restoreCursor(), e) {
+          const n = Math.max(0, e.numLinesAfter - i), s = Math.max(0, e.numLinesBefore - i);
+          let r = e.lines.find((o) => o >= n);
+          if (r === undefined) {
+            this._prevFrame = t2;
+            return;
+          }
+          if (e.lines.length === 1) {
+            this.output.write(import_sisteransi.cursor.move(0, r - s)), this.output.write(import_sisteransi.erase.lines(1));
+            const o = t2.split(`
+`);
+            this.output.write(o[r]), this._prevFrame = t2, this.output.write(import_sisteransi.cursor.move(0, o.length - r - 1));
+            return;
+          } else if (e.lines.length > 1) {
+            if (n < s)
+              r = n;
+            else {
+              const h = r - s;
+              h > 0 && this.output.write(import_sisteransi.cursor.move(0, h));
+            }
+            this.output.write(import_sisteransi.erase.down());
+            const f = t2.split(`
+`).slice(r);
+            this.output.write(f.join(`
+`)), this._prevFrame = t2;
+            return;
+          }
+        }
+        this.output.write(import_sisteransi.erase.down());
+      }
+      this.output.write(t2), this.state === "initial" && (this.state = "active"), this._prevFrame = t2;
+    }
+  }
+}
+class a extends V {
+  options;
+  cursor = 0;
+  get _value() {
+    return this.options[this.cursor]?.value;
+  }
+  get _enabledOptions() {
+    return this.options.filter((e) => e.disabled !== true);
+  }
+  toggleAll() {
+    const e = this._enabledOptions, i = this.value !== undefined && this.value.length === e.length;
+    this.value = i ? [] : e.map((t2) => t2.value);
+  }
+  toggleInvert() {
+    const e = this.value;
+    if (!e)
+      return;
+    const i = this._enabledOptions.filter((t2) => !e.includes(t2.value));
+    this.value = i.map((t2) => t2.value);
+  }
+  toggleValue() {
+    this.value === undefined && (this.value = []);
+    const e = this.value.includes(this._value);
+    this.value = e ? this.value.filter((i) => i !== this._value) : [...this.value, this._value];
+  }
+  constructor(e) {
+    super(e, false), this.options = e.options, this.value = [...e.initialValues ?? []];
+    const i = Math.max(this.options.findIndex(({ value: t2 }) => t2 === e.cursorAt), 0);
+    this.cursor = this.options[i]?.disabled ? findCursor(i, 1, this.options) : i, this.on("key", (t2, l2) => {
+      l2.name === "a" && this.toggleAll(), l2.name === "i" && this.toggleInvert();
+    }), this.on("cursor", (t2) => {
+      switch (t2) {
+        case "left":
+        case "up":
+          this.cursor = findCursor(this.cursor, -1, this.options);
+          break;
+        case "down":
+        case "right":
+          this.cursor = findCursor(this.cursor, 1, this.options);
+          break;
+        case "space":
+          this.toggleValue();
+          break;
+      }
+    });
+  }
+}
+var n$1 = class n extends V {
+  options;
+  cursor = 0;
+  get _selectedValue() {
+    return this.options[this.cursor];
+  }
+  changeValue() {
+    const e = this._selectedValue;
+    this.value = e === undefined ? undefined : e.value;
+  }
+  constructor(e) {
+    super(e, false), this.options = e.options;
+    const o = this.options.findIndex(({ value: s }) => s === e.initialValue), t2 = o === -1 ? 0 : o;
+    this.cursor = this.options[t2]?.disabled ? findCursor(t2, 1, this.options) : t2, this.changeValue(), this.on("cursor", (s) => {
+      switch (s) {
+        case "left":
+        case "up":
+          this.cursor = findCursor(this.cursor, -1, this.options);
+          break;
+        case "down":
+        case "right":
+          this.cursor = findCursor(this.cursor, 1, this.options);
+          break;
+      }
+      this.changeValue();
+    });
+  }
+};
+class n2 extends V {
+  get userInputWithCursor() {
+    if (this.state === "submit")
+      return this.userInput;
+    const t2 = this.userInput;
+    if (this.cursor >= t2.length)
+      return `${this.userInput}█`;
+    const r = t2.slice(0, this.cursor), s = t2.slice(this.cursor, this.cursor + 1), e = t2.slice(this.cursor + 1);
+    return `${r}${styleText("inverse", s)}${e}`;
+  }
+  get cursor() {
+    return this._cursor;
+  }
+  constructor(t2) {
+    super({
+      ...t2,
+      initialUserInput: t2.initialUserInput ?? t2.initialValue
+    }), this.on("userInput", (r) => {
+      this._setValue(r);
+    }), this.on("finalize", () => {
+      this.value || (this.value = t2.defaultValue), this.value === undefined && (this.value = "");
+    });
+  }
+}
+
+// ../../node_modules/.bun/@clack+prompts@1.7.0/node_modules/@clack/prompts/dist/index.mjs
+import { styleText as styleText2, stripVTControlCharacters } from "node:util";
+import process$1 from "node:process";
+var import_sisteransi2 = __toESM(require_src(), 1);
+function isUnicodeSupported() {
+  if (process$1.platform !== "win32") {
+    return process$1.env.TERM !== "linux";
+  }
+  return Boolean(process$1.env.CI) || Boolean(process$1.env.WT_SESSION) || Boolean(process$1.env.TERMINUS_SUBLIME) || process$1.env.ConEmuTask === "{cmd::Cmder}" || process$1.env.TERM_PROGRAM === "Terminus-Sublime" || process$1.env.TERM_PROGRAM === "vscode" || process$1.env.TERM === "xterm-256color" || process$1.env.TERM === "alacritty" || process$1.env.TERMINAL_EMULATOR === "JetBrains-JediTerm";
+}
+var unicode = isUnicodeSupported();
+var isCI = () => process.env.CI === "true";
+var unicodeOr = (o, e) => unicode ? o : e;
+var S_STEP_ACTIVE = unicodeOr("◆", "*");
+var S_STEP_CANCEL = unicodeOr("■", "x");
+var S_STEP_ERROR = unicodeOr("▲", "x");
+var S_STEP_SUBMIT = unicodeOr("◇", "o");
+var S_BAR_START = unicodeOr("┌", "T");
+var S_BAR = unicodeOr("│", "|");
+var S_BAR_END = unicodeOr("└", "—");
+var S_BAR_START_RIGHT = unicodeOr("┐", "T");
+var S_BAR_END_RIGHT = unicodeOr("┘", "—");
+var S_RADIO_ACTIVE = unicodeOr("●", ">");
+var S_RADIO_INACTIVE = unicodeOr("○", " ");
+var S_CHECKBOX_ACTIVE = unicodeOr("◻", "[•]");
+var S_CHECKBOX_SELECTED = unicodeOr("◼", "[+]");
+var S_CHECKBOX_INACTIVE = unicodeOr("◻", "[ ]");
+var S_PASSWORD_MASK = unicodeOr("▪", "•");
+var S_BAR_H = unicodeOr("─", "-");
+var S_CORNER_TOP_RIGHT = unicodeOr("╮", "+");
+var S_CONNECT_LEFT = unicodeOr("├", "+");
+var S_CORNER_BOTTOM_RIGHT = unicodeOr("╯", "+");
+var S_CORNER_BOTTOM_LEFT = unicodeOr("╰", "+");
+var S_CORNER_TOP_LEFT = unicodeOr("╭", "+");
+var S_INFO = unicodeOr("●", "•");
+var S_SUCCESS = unicodeOr("◆", "*");
+var S_WARN = unicodeOr("▲", "!");
+var S_ERROR = unicodeOr("■", "x");
+var symbol = (o) => {
+  switch (o) {
+    case "initial":
+    case "active":
+      return styleText2("cyan", S_STEP_ACTIVE);
+    case "cancel":
+      return styleText2("red", S_STEP_CANCEL);
+    case "error":
+      return styleText2("yellow", S_STEP_ERROR);
+    case "submit":
+      return styleText2("green", S_STEP_SUBMIT);
+  }
+};
+var symbolBar = (o) => {
+  switch (o) {
+    case "initial":
+    case "active":
+      return styleText2("cyan", S_BAR);
+    case "cancel":
+      return styleText2("red", S_BAR);
+    case "error":
+      return styleText2("yellow", S_BAR);
+    case "submit":
+      return styleText2("green", S_BAR);
+  }
+};
+function formatInstructionFooter(o, e) {
+  const r2 = [`${e ? `${styleText2("cyan", S_BAR)}  ` : ""}${o.join(" • ")}`];
+  return e && r2.push(styleText2("cyan", S_BAR_END)), r2;
+}
+var I = (l2, e, w, p, b, C = false) => {
+  let r2 = e, O = 0;
+  if (C)
+    for (let i = p - 1;i >= w; i--) {
+      const m = l2[i];
+      if (m && (r2 -= m.length), O++, r2 <= b)
+        break;
+    }
+  else
+    for (let i = w;i < p; i++) {
+      const m = l2[i];
+      if (m && (r2 -= m.length), O++, r2 <= b)
+        break;
+    }
+  return { lineCount: r2, removals: O };
+};
+var limitOptions = ({
+  cursor: l2,
+  options: e,
+  style: w,
+  output: p = process.stdout,
+  maxItems: b = Number.POSITIVE_INFINITY,
+  columnPadding: C = 0,
+  rowPadding: r2 = 4
+}) => {
+  const i = getColumns(p) - C, m = getRows(p), M = styleText2("dim", "..."), v = Math.max(m - r2, 0), a2 = Math.max(Math.min(b, v), 5);
+  let f = 0;
+  l2 >= a2 - 3 && (f = Math.max(Math.min(l2 - a2 + 3, e.length - a2), 0));
+  let d = a2 < e.length && f > 0, c = a2 < e.length && f + a2 < e.length;
+  const W = Math.min(f + a2, e.length), s = [];
+  let g = 0;
+  d && g++, c && g++;
+  const T = f + (d ? 1 : 0), y = W - (c ? 1 : 0);
+  for (let t2 = T;t2 < y; t2++) {
+    const n3 = e[t2], o = n3 ? w(n3, t2 === l2) : "", h2 = wrapAnsi(o, i, {
+      hard: true,
+      trim: false
+    }).split(`
+`);
+    s.push(h2), g += h2.length;
+  }
+  if (g > v) {
+    let t2 = 0, n3 = 0, o = g;
+    const h2 = l2 - T;
+    let u2 = v;
+    const L = () => I(s, o, 0, h2, u2), E = () => I(s, o, h2 + 1, s.length, u2, true);
+    d ? ({ lineCount: o, removals: t2 } = L(), o > u2 && (c || (u2 -= 1), { lineCount: o, removals: n3 } = E())) : (c || (u2 -= 1), { lineCount: o, removals: n3 } = E(), o > u2 && (u2 -= 1, { lineCount: o, removals: t2 } = L())), t2 > 0 && (d = true, s.splice(0, t2)), n3 > 0 && (c = true, s.splice(s.length - n3, n3));
+  }
+  const x = [];
+  d && x.push(M);
+  for (const t2 of s)
+    for (const n3 of t2)
+      x.push(n3);
+  return c && x.push(M), x;
+};
+var MULTISELECT_INSTRUCTIONS = [
+  `${styleText2("dim", "↑/↓")} to navigate`,
+  `${styleText2("dim", "Space:")} select`,
+  `${styleText2("dim", "Enter:")} confirm`
+];
+var m = (i, u2) => i.split(`
+`).map((d) => u2(d)).join(`
+`);
+var multiselect = (i) => {
+  const u2 = (t2, a2) => {
+    const r2 = t2.label ?? String(t2.value);
+    return a2 === "disabled" ? `${styleText2("gray", S_CHECKBOX_INACTIVE)} ${m(r2, (o) => styleText2(["strikethrough", "gray"], o))}${t2.hint ? ` ${styleText2("dim", `(${t2.hint ?? "disabled"})`)}` : ""}` : a2 === "active" ? `${styleText2("cyan", S_CHECKBOX_ACTIVE)} ${r2}${t2.hint ? ` ${styleText2("dim", `(${t2.hint})`)}` : ""}` : a2 === "selected" ? `${styleText2("green", S_CHECKBOX_SELECTED)} ${m(r2, (o) => styleText2("dim", o))}${t2.hint ? ` ${styleText2("dim", `(${t2.hint})`)}` : ""}` : a2 === "cancelled" ? `${m(r2, (o) => styleText2(["strikethrough", "dim"], o))}` : a2 === "active-selected" ? `${styleText2("green", S_CHECKBOX_SELECTED)} ${r2}${t2.hint ? ` ${styleText2("dim", `(${t2.hint})`)}` : ""}` : a2 === "submitted" ? `${m(r2, (o) => styleText2("dim", o))}` : `${styleText2("dim", S_CHECKBOX_INACTIVE)} ${m(r2, (o) => styleText2("dim", o))}`;
+  }, d = i.required ?? true, v = i.showInstructions ?? true;
+  return new a({
+    options: i.options,
+    signal: i.signal,
+    input: i.input,
+    output: i.output,
+    initialValues: i.initialValues,
+    required: d,
+    cursorAt: i.cursorAt,
+    validate(t2) {
+      if (d && (t2 === undefined || t2.length === 0))
+        return `Please select at least one option.
+${styleText2("reset", styleText2("dim", `Press ${styleText2(["gray", "bgWhite", "inverse"], " space ")} to select, ${styleText2("gray", styleText2("bgWhite", styleText2("inverse", " enter ")))} to submit`))}`;
+    },
+    render() {
+      const t2 = i.withGuide ?? settings.withGuide, a2 = wrapTextWithPrefix(i.output, i.message, t2 ? `${symbolBar(this.state)}  ` : "", `${symbol(this.state)}  `), r2 = `${t2 ? `${styleText2("gray", S_BAR)}
+` : ""}${a2}
+`, o = this.value ?? [], p = (n3, l2) => {
+        if (n3.disabled)
+          return u2(n3, "disabled");
+        const s = o.includes(n3.value);
+        return l2 && s ? u2(n3, "active-selected") : s ? u2(n3, "selected") : u2(n3, l2 ? "active" : "inactive");
+      };
+      switch (this.state) {
+        case "submit": {
+          const n3 = this.options.filter(({ value: s }) => o.includes(s)).map((s) => u2(s, "submitted")).join(styleText2("dim", ", ")) || styleText2("dim", "none"), l2 = wrapTextWithPrefix(i.output, n3, t2 ? `${styleText2("gray", S_BAR)}  ` : "");
+          return `${r2}${l2}`;
+        }
+        case "cancel": {
+          const n3 = this.options.filter(({ value: s }) => o.includes(s)).map((s) => u2(s, "cancelled")).join(styleText2("dim", ", "));
+          if (n3.trim() === "")
+            return `${r2}${styleText2("gray", S_BAR)}`;
+          const l2 = wrapTextWithPrefix(i.output, n3, t2 ? `${styleText2("gray", S_BAR)}  ` : "");
+          return `${r2}${l2}${t2 ? `
+${styleText2("gray", S_BAR)}` : ""}`;
+        }
+        case "error": {
+          const n3 = t2 ? `${styleText2("yellow", S_BAR)}  ` : "", l2 = this.error.split(`
+`).map(($, C) => C === 0 ? `${t2 ? `${styleText2("yellow", S_BAR_END)}  ` : ""}${styleText2("yellow", $)}` : `   ${$}`).join(`
+`), s = r2.split(`
+`).length, h2 = l2.split(`
+`).length + 1;
+          return `${r2}${n3}${limitOptions({
+            output: i.output,
+            options: this.options,
+            cursor: this.cursor,
+            maxItems: i.maxItems,
+            columnPadding: n3.length,
+            rowPadding: s + h2,
+            style: p
+          }).join(`
+${n3}`)}
+${l2}
+`;
+        }
+        default: {
+          const n3 = t2 ? `${styleText2("cyan", S_BAR)}  ` : "", l2 = r2.split(`
+`).length, s = v ? formatInstructionFooter(MULTISELECT_INSTRUCTIONS, t2) : t2 ? [styleText2("cyan", S_BAR_END)] : [], h2 = s.join(`
+`), $ = s.length + 1;
+          return `${r2}${n3}${limitOptions({
+            output: i.output,
+            options: this.options,
+            cursor: this.cursor,
+            maxItems: i.maxItems,
+            columnPadding: n3.length,
+            rowPadding: l2 + $,
+            style: p
+          }).join(`
+${n3}`)}
+${h2}
+`;
+        }
+      }
+    }
+  }).prompt();
+};
+var log = {
+  message: (s = [], {
+    symbol: e = styleText2("gray", S_BAR),
+    secondarySymbol: r2 = styleText2("gray", S_BAR),
+    output: m2 = process.stdout,
+    spacing: l2 = 1,
+    withGuide: c
+  } = {}) => {
+    const t2 = [], o = c ?? settings.withGuide, f = o ? r2 : "", O = o ? `${e}  ` : "", u2 = o ? `${r2}  ` : "";
+    for (let i = 0;i < l2; i++)
+      t2.push(f);
+    const g = Array.isArray(s) ? s : s.split(`
+`);
+    if (g.length > 0) {
+      const [i, ...y] = g;
+      i.length > 0 ? t2.push(`${O}${i}`) : t2.push(o ? e : "");
+      for (const p of y)
+        p.length > 0 ? t2.push(`${u2}${p}`) : t2.push(o ? r2 : "");
+    }
+    m2.write(`${t2.join(`
+`)}
+`);
+  },
+  info: (s, e) => {
+    log.message(s, { ...e, symbol: styleText2("blue", S_INFO) });
+  },
+  success: (s, e) => {
+    log.message(s, { ...e, symbol: styleText2("green", S_SUCCESS) });
+  },
+  step: (s, e) => {
+    log.message(s, { ...e, symbol: styleText2("green", S_STEP_SUBMIT) });
+  },
+  warn: (s, e) => {
+    log.message(s, { ...e, symbol: styleText2("yellow", S_WARN) });
+  },
+  warning: (s, e) => {
+    log.warn(s, e);
+  },
+  error: (s, e) => {
+    log.message(s, { ...e, symbol: styleText2("red", S_ERROR) });
+  }
+};
+var cancel = (o = "", t2) => {
+  const i = t2?.output ?? process.stdout, e = t2?.withGuide ?? settings.withGuide ? `${styleText2("gray", S_BAR_END)}  ` : "";
+  i.write(`${e}${styleText2("red", o)}
+
+`);
+};
+var intro = (o = "", t2) => {
+  const i = t2?.output ?? process.stdout, e = t2?.withGuide ?? settings.withGuide ? `${styleText2("gray", S_BAR_START)}  ` : "";
+  i.write(`${e}${o}
+`);
+};
+var outro = (o = "", t2) => {
+  const i = t2?.output ?? process.stdout, e = t2?.withGuide ?? settings.withGuide ? `${styleText2("gray", S_BAR)}
+${styleText2("gray", S_BAR_END)}  ` : "";
+  i.write(`${e}${o}
+
+`);
+};
+var W$1 = (o) => o;
+var C = (o, e, s) => {
+  const a2 = {
+    hard: true,
+    trim: false
+  }, i = wrapAnsi(o, e, a2).split(`
+`), c = i.reduce((n3, t2) => Math.max(dist_default2(t2), n3), 0), u2 = i.map(s).reduce((n3, t2) => Math.max(dist_default2(t2), n3), 0), g = e - (u2 - c);
+  return wrapAnsi(o, g, a2);
+};
+var note = (o = "", e = "", s) => {
+  const a2 = s?.output ?? process$1.stdout, i = s?.withGuide ?? settings.withGuide, c = s?.format ?? W$1, g = ["", ...C(o, getColumns(a2) - 6, c).split(`
+`).map(c), ""], n3 = dist_default2(e), t2 = Math.max(g.reduce((m2, F) => {
+    const O = dist_default2(F);
+    return O > m2 ? O : m2;
+  }, 0), n3) + 2, h2 = g.map((m2) => `${styleText2("gray", S_BAR)}  ${m2}${" ".repeat(t2 - dist_default2(m2))}${styleText2("gray", S_BAR)}`).join(`
+`), T = i ? `${styleText2("gray", S_BAR)}
+` : "", l$1 = i ? S_CONNECT_LEFT : S_CORNER_BOTTOM_LEFT;
+  a2.write(`${T}${styleText2("green", S_STEP_SUBMIT)}  ${styleText2("reset", e)} ${styleText2("gray", S_BAR_H.repeat(Math.max(t2 - n3 - 1, 1)) + S_CORNER_TOP_RIGHT)}
+${h2}
+${styleText2("gray", l$1 + S_BAR_H.repeat(t2 + 2) + S_CORNER_BOTTOM_RIGHT)}
+`);
+};
+var W = (l2) => styleText2("magenta", l2);
+var spinner = ({
+  indicator: l2 = "dots",
+  onCancel: h2,
+  output: n3 = process.stdout,
+  cancelMessage: G,
+  errorMessage: O,
+  frames: E = unicode ? ["◒", "◐", "◓", "◑"] : ["•", "o", "O", "0"],
+  delay: F = unicode ? 80 : 120,
+  signal: m2,
+  ...I2
+} = {}) => {
+  const u2 = isCI();
+  let M, T, d = false, S = false, s = "", p, w = performance.now();
+  const x = getColumns(n3), k = I2?.styleFrame ?? W, g = (e) => {
+    const r2 = e > 1 ? O ?? settings.messages.error : G ?? settings.messages.cancel;
+    S = e === 1, d && (a2(r2, e), S && typeof h2 == "function" && h2());
+  }, f = () => g(2), i = () => g(1), A = () => {
+    process.on("uncaughtExceptionMonitor", f), process.on("unhandledRejection", f), process.on("SIGINT", i), process.on("SIGTERM", i), process.on("exit", g), m2 && m2.addEventListener("abort", i);
+  }, H = () => {
+    process.removeListener("uncaughtExceptionMonitor", f), process.removeListener("unhandledRejection", f), process.removeListener("SIGINT", i), process.removeListener("SIGTERM", i), process.removeListener("exit", g), m2 && m2.removeEventListener("abort", i);
+  }, y = () => {
+    if (p === undefined)
+      return;
+    u2 && n3.write(`
+`);
+    const r2 = wrapAnsi(p, x, {
+      hard: true,
+      trim: false
+    }).split(`
+`);
+    r2.length > 1 && n3.write(import_sisteransi2.cursor.up(r2.length - 1)), n3.write(import_sisteransi2.cursor.to(0)), n3.write(import_sisteransi2.erase.down());
+  }, C2 = (e) => e.replace(/\.+$/, ""), _ = (e) => {
+    const r2 = (performance.now() - e) / 1000, t2 = Math.floor(r2 / 60), o = Math.floor(r2 % 60);
+    return t2 > 0 ? `[${t2}m ${o}s]` : `[${o}s]`;
+  }, N = I2.withGuide ?? settings.withGuide, P = (e = "") => {
+    d = true, M = block({ output: n3 }), s = C2(e), w = performance.now(), N && n3.write(`${styleText2("gray", S_BAR)}
+`);
+    let r2 = 0, t2 = 0;
+    A(), T = setInterval(() => {
+      if (u2 && s === p)
+        return;
+      y(), p = s;
+      const o = k(E[r2]);
+      let v;
+      if (u2)
+        v = `${o}  ${s}...`;
+      else if (l2 === "timer")
+        v = `${o}  ${s} ${_(w)}`;
+      else {
+        const B = ".".repeat(Math.floor(t2)).slice(0, 3);
+        v = `${o}  ${s}${B}`;
+      }
+      const j = wrapAnsi(v, x, {
+        hard: true,
+        trim: false
+      });
+      n3.write(j), r2 = r2 + 1 < E.length ? r2 + 1 : 0, t2 = t2 < 4 ? t2 + 0.125 : 0;
+    }, F);
+  }, a2 = (e = "", r2 = 0, t2 = false) => {
+    if (!d)
+      return;
+    d = false, clearInterval(T), y();
+    const o = r2 === 0 ? styleText2("green", S_STEP_SUBMIT) : r2 === 1 ? styleText2("red", S_STEP_CANCEL) : styleText2("red", S_STEP_ERROR);
+    s = e ?? s, t2 || (l2 === "timer" ? n3.write(`${o}  ${s} ${_(w)}
+`) : n3.write(`${o}  ${s}
+`)), H(), M();
+  };
+  return {
+    start: P,
+    stop: (e = "") => a2(e, 0),
+    message: (e = "") => {
+      s = C2(e ?? s);
+    },
+    cancel: (e = "") => a2(e, 1),
+    error: (e = "") => a2(e, 2),
+    clear: () => a2("", 0, true),
+    get isCancelled() {
+      return S;
+    }
+  };
+};
+var u2 = {
+  light: unicodeOr("─", "-"),
+  heavy: unicodeOr("━", "="),
+  block: unicodeOr("█", "#")
+};
+var SELECT_INSTRUCTIONS = [
+  `${styleText2("dim", "↑/↓")} to navigate`,
+  `${styleText2("dim", "Enter:")} confirm`
+];
+var c = (t2, o) => t2.includes(`
+`) ? t2.split(`
+`).map((d) => o(d)).join(`
+`) : o(t2);
+var select = (t2) => {
+  const o = (n3, m2) => {
+    if (n3 === undefined)
+      return "";
+    const s = n3.label ?? String(n3.value);
+    switch (m2) {
+      case "disabled":
+        return `${styleText2("gray", S_RADIO_INACTIVE)} ${c(s, (i) => styleText2("gray", i))}${n3.hint ? ` ${styleText2("dim", `(${n3.hint ?? "disabled"})`)}` : ""}`;
+      case "selected":
+        return `${c(s, (i) => styleText2("dim", i))}`;
+      case "active":
+        return `${styleText2("green", S_RADIO_ACTIVE)} ${s}${n3.hint ? ` ${styleText2("dim", `(${n3.hint})`)}` : ""}`;
+      case "cancelled":
+        return `${c(s, (i) => styleText2(["strikethrough", "dim"], i))}`;
+      default:
+        return `${styleText2("dim", S_RADIO_INACTIVE)} ${c(s, (i) => styleText2("dim", i))}`;
+    }
+  }, d = t2.showInstructions ?? true;
+  return new n$1({
+    options: t2.options,
+    signal: t2.signal,
+    input: t2.input,
+    output: t2.output,
+    initialValue: t2.initialValue,
+    render() {
+      const n3 = t2.withGuide ?? settings.withGuide, m2 = `${symbol(this.state)}  `, s = `${symbolBar(this.state)}  `, i = wrapTextWithPrefix(t2.output, t2.message, s, m2), u3 = `${n3 ? `${styleText2("gray", S_BAR)}
+` : ""}${i}
+`;
+      switch (this.state) {
+        case "submit": {
+          const r2 = n3 ? `${styleText2("gray", S_BAR)}  ` : "", a2 = wrapTextWithPrefix(t2.output, o(this.options[this.cursor], "selected"), r2);
+          return `${u3}${a2}`;
+        }
+        case "cancel": {
+          const r2 = n3 ? `${styleText2("gray", S_BAR)}  ` : "", a2 = wrapTextWithPrefix(t2.output, o(this.options[this.cursor], "cancelled"), r2);
+          return `${u3}${a2}${n3 ? `
+${styleText2("gray", S_BAR)}` : ""}`;
+        }
+        default: {
+          const r2 = n3 ? `${styleText2("cyan", S_BAR)}  ` : "", a2 = u3.split(`
+`).length, p = d ? formatInstructionFooter(SELECT_INSTRUCTIONS, n3) : n3 ? [styleText2("cyan", S_BAR_END)] : [], b = p.join(`
+`), f = p.length + 1;
+          return `${u3}${r2}${limitOptions({
+            output: t2.output,
+            cursor: this.cursor,
+            options: this.options,
+            maxItems: t2.maxItems,
+            columnPadding: r2.length,
+            rowPadding: a2 + f,
+            style: (g, x) => o(g, g.disabled ? "disabled" : x ? "active" : "inactive")
+          }).join(`
+${r2}`)}
+${b}
+`;
+        }
+      }
+    }
+  }).prompt();
+};
+var i = `${styleText2("gray", S_BAR)}  `;
+var text = (e) => new n2({
+  validate: e.validate,
+  placeholder: e.placeholder,
+  defaultValue: e.defaultValue,
+  initialValue: e.initialValue,
+  output: e.output,
+  signal: e.signal,
+  input: e.input,
+  render() {
+    const i2 = e?.withGuide ?? settings.withGuide, s = `${`${i2 ? `${styleText2("gray", S_BAR)}
+` : ""}${symbol(this.state)}  `}${e.message}
+`, c2 = e.placeholder && e.placeholder.length > 0 ? styleText2("inverse", e.placeholder[0]) + styleText2("dim", e.placeholder.slice(1)) : styleText2(["inverse", "hidden"], "_"), o = this.userInput ? this.userInputWithCursor : c2, l2 = this.value ?? "";
+    switch (this.state) {
+      case "error": {
+        const n3 = this.error ? `  ${styleText2("yellow", this.error)}` : "", r2 = i2 ? `${styleText2("yellow", S_BAR)}  ` : "", d = i2 ? styleText2("yellow", S_BAR_END) : "";
+        return `${s.trim()}
+${r2}${o}
+${d}${n3}
+`;
+      }
+      case "submit": {
+        const n3 = l2 ? `  ${styleText2("dim", l2)}` : "", r2 = i2 ? styleText2("gray", S_BAR) : "";
+        return `${s}${r2}${n3}`;
+      }
+      case "cancel": {
+        const n3 = l2 ? `  ${styleText2(["strikethrough", "dim"], l2)}` : "", r2 = i2 ? styleText2("gray", S_BAR) : "";
+        return `${s}${r2}${n3}${l2.trim() ? `
+${r2}` : ""}`;
+      }
+      default: {
+        const n3 = i2 ? `${styleText2("cyan", S_BAR)}  ` : "", r2 = i2 ? styleText2("cyan", S_BAR_END) : "";
+        return `${s}${n3}${o}
+${r2}
+`;
+      }
+    }
+  }
+}).prompt();
+
+// src/ui.ts
+import { resolve as resolve3 } from "node:path";
+var hint = (s) => s.replace(/\s+/g, " ").trim().slice(0, 90);
+var cancelled = () => {
+  cancel("Installation cancelled.");
+  return 1;
+};
+function report(result, target, home) {
+  if (result.installed.length)
+    log.success(`Installed: ${result.installed.join(", ")}`);
+  if (result.overwritten.length)
+    log.info(`Overwritten: ${result.overwritten.join(", ")}`);
+  if (result.skipped.length)
+    log.warn(`Skipped (already installed): ${result.skipped.join(", ")}`);
+  for (const f of result.failed)
+    log.error(`${f.name}: ${f.error}`);
+  note(`Install target: ${displayPath(target, home)}`, "Done");
+}
+async function runInteractive(ctx) {
+  intro("Grimoire");
+  const registry = listSkills(ctx.catalogDir);
+  if (!registry.length) {
+    log.error("No skills found in the catalog.");
+    return 1;
+  }
+  const grouped = categories(registry);
+  const root = await select({ message: "What would you like to do?", options: [
+    ...grouped.map((c2) => ({ value: `category:${c2.name}`, label: c2.name, hint: `${c2.skills.length} skill(s)` })),
+    { value: "detect", label: "Detect project skills", hint: "Analyze this project and recommend relevant skills" },
+    { value: "search", label: "Search all skills", hint: "Find a skill by name or description" }
+  ] });
+  if (isCancel(root))
+    return cancelled();
+  let selected;
+  if (root === "detect") {
+    const detection = detectStack(ctx.projectDir ?? process.cwd(), registry);
+    if (!detection.recommendations.length)
+      log.info("No matching recommendations found; browse a category instead.");
+    else
+      note(detection.recommendations.map((r2) => `${r2.name}: ${r2.reason}`).join(`
+`), `Detected ${detection.stack.join(", ") || "no known stack"}`);
+    const picked = await multiselect({ message: "Review recommendations (add or remove skills)", options: registry.map((s) => ({ value: s.name, label: s.name, hint: hint(s.description), initialValue: detection.skills.includes(s.name) })), required: true });
+    if (isCancel(picked))
+      return cancelled();
+    selected = picked;
+  } else {
+    let options;
+    if (root === "search") {
+      const query = await text({ message: "Search skills" });
+      if (isCancel(query))
+        return cancelled();
+      const needle = String(query).toLowerCase();
+      options = registry.filter((s) => `${s.name} ${s.description} ${s.category}`.toLowerCase().includes(needle));
+      if (!options.length) {
+        log.error("No matching skills.");
+        return 1;
+      }
+    } else
+      options = grouped.find((c2) => c2.name === String(root).slice(9))?.skills ?? registry;
+    const picked = await multiselect({ message: "Select skills (space to toggle, enter to continue)", options: options.map((s) => ({ value: s.name, label: s.name, hint: hint(s.description) })), required: true });
+    if (isCancel(picked))
+      return cancelled();
+    selected = picked;
+  }
+  const review = await multiselect({ message: `Review selection: ${selected.length} skill(s)`, options: registry.map((s) => ({ value: s.name, label: s.name, hint: s.category })), initialValues: selected, required: true });
+  if (isCancel(review))
+    return cancelled();
+  selected = review;
+  const target = ctx.targetDirOverride ? undefined : await select({ message: "Which destination agent should receive them?", options: TARGETS.map((t2) => ({ value: t2.id, label: t2.label, hint: displayPath(resolveSkillsDir(t2.id, { home: ctx.home, env: ctx.env, projectDir: ctx.projectDir, global: ctx.global }), ctx.home) })) });
+  if (target !== undefined && isCancel(target))
+    return cancelled();
+  const targetDir = ctx.targetDirOverride ?? resolveSkillsDir(target, { home: ctx.home, env: ctx.env, projectDir: ctx.projectDir, global: ctx.global });
+  let overwrite = ctx.overwrite ?? false;
+  const conflicts = findConflicts(targetDir, selected);
+  if (conflicts.length && !overwrite) {
+    const mode = await select({ message: "Some selected skills already exist. How should Grimoire proceed?", options: [{ value: "skip", label: "Keep existing copies" }, { value: "overwrite", label: "Overwrite existing copies" }, { value: "cancel", label: "Cancel" }] });
+    if (isCancel(mode) || mode === "cancel")
+      return cancelled();
+    overwrite = mode === "overwrite";
+  }
+  const confirmed = await select({ message: `Install ${selected.length} skill(s) to ${displayPath(targetDir, ctx.home)}?`, options: [{ value: "confirm", label: "Confirm installation" }, { value: "cancel", label: "Cancel" }] });
+  if (isCancel(confirmed) || confirmed !== "confirm")
+    return cancelled();
+  const spin = spinner();
+  spin.start("Installing");
+  const result = installSkills({ catalogDir: ctx.catalogDir, targetDir, names: selected, overwrite, onStatus: (name) => spin.message(`Installing ${name}`) });
+  spin.stop("Installation complete");
+  if (!ctx.global && (result.installed.length || result.overwritten.length)) {
+    const projectDir = resolve3(ctx.projectDir ?? process.cwd());
+    const lock = readLockfile(projectDir);
+    for (const name of [...result.installed, ...result.overwritten]) {
+      const skill = findSkill(ctx.catalogDir, name);
+      if (skill)
+        updateLock(lock, name, { version: skill.version, hash: skillHash(skill.dir), installed: new Date().toISOString(), agents: [target ? String(target) : "custom"] });
+    }
+    writeLockfile(projectDir, lock);
+  }
+  report(result, targetDir, ctx.home);
+  outro("Ready");
+  return result.failed.length ? 1 : 0;
+}
+
+// src/index.ts
+var packageRoot = resolve4(fileURLToPath(new URL("..", import.meta.url)));
+var catalogDir = existsSync5(join7(packageRoot, "skills")) ? join7(packageRoot, "skills") : resolve4(packageRoot, "../../skills/skills");
+var usage = `grimoire — browse and install agent skills
+
+Usage:
+  grimoire                         interactive catalog (default)
+  grimoire install -s <skill> -t <agent>   noninteractive install
+  grimoire list|search [query]     browse the catalog
+  grimoire detect                  recommend skills for this project
+  grimoire status                  show project lockfile
+
+Agents: ${TARGETS.map((t2) => t2.id).join(", ")}
+Options: --global --target-dir <dir> --overwrite --help --version`;
+function value(args, flag) {
+  const i2 = args.indexOf(flag);
+  return i2 < 0 ? undefined : args[i2 + 1];
+}
+function print(skills, query = "") {
+  for (const s of skills.filter((s2) => !query || `${s2.name} ${s2.description} ${s2.category}`.toLowerCase().includes(query.toLowerCase())))
+    console.log(`${s.name} [${s.category}] — ${s.description.split(`
+`)[0]}`);
+}
+function version() {
+  try {
+    return JSON.parse(readFileSync5(join7(packageRoot, "package.json"), "utf8")).version;
+  } catch {
+    return "0.0.0";
+  }
+}
+async function main() {
+  const args = process.argv.slice(2);
+  if (!args.length || args[0] === "--global")
+    return runInteractive({ catalogDir, home: homedir2(), projectDir: resolve4(process.cwd()), global: args.includes("--global") });
+  if (args.includes("--help") || args.includes("-h")) {
+    console.log(usage);
+    return 0;
+  }
+  if (args.includes("--version")) {
+    console.log(version());
+    return 0;
+  }
+  const registry = readRegistry(catalogDir);
+  const command = args[0];
+  if (command === "list" || command === "search") {
+    print(registry, command === "search" ? args[1] ?? "" : "");
+    return 0;
+  }
+  if (command === "detect") {
+    const d = detectStack(resolve4(process.cwd()), registry);
+    console.log(`Detected: ${d.stack.join(", ") || "no known stack"}`);
+    for (const r2 of d.recommendations)
+      console.log(`  ${r2.name} — ${r2.reason}`);
+    return 0;
+  }
+  if (command === "status") {
+    const lock = readLockfile(resolve4(process.cwd()));
+    const entries = Object.entries(lock.skills);
+    if (!entries.length) {
+      console.log("No tracked project installations.");
+      return 0;
+    }
+    for (const [name, entry] of entries)
+      console.log(`${name} [${entry.agents.join(", ")}] ${entry.hash}`);
+    return 0;
+  }
+  if (command !== "install")
+    throw new Error(`unknown command: ${command}`);
+  const names = args.flatMap((a2, i2) => a2 === "-s" || a2 === "--skill" ? [args[i2 + 1]] : []).filter(Boolean);
+  const target = value(args, "-t") ?? value(args, "--target");
+  if (!names.length || !target || !isTargetId(target))
+    throw new Error(`noninteractive install requires --skill and --target (${TARGETS.map((t2) => t2.id).join(", ")})`);
+  const unknown = names.filter((n3) => !findSkill(catalogDir, n3));
+  if (unknown.length)
+    throw new Error(`unknown skill(s): ${unknown.join(", ")}`);
+  const global = args.includes("--global");
+  const projectDir = resolve4(process.cwd());
+  const dir = value(args, "--target-dir") ?? resolveSkillsDir(target, { home: homedir2(), projectDir, global });
+  const result = installSkills({ catalogDir, targetDir: resolve4(dir), names, overwrite: args.includes("--overwrite") });
+  if (!global) {
+    const lock = readLockfile(projectDir);
+    for (const name of [...result.installed, ...result.overwritten]) {
+      const skill = findSkill(catalogDir, name);
+      if (skill)
+        updateLock(lock, name, { version: skill.version, hash: skillHash(skill.dir), installed: new Date().toISOString(), agents: [target] });
+    }
+    if (result.installed.length || result.overwritten.length)
+      writeLockfile(projectDir, lock);
+  }
+  if (result.installed.length)
+    console.log(`installed: ${result.installed.join(", ")}`);
+  if (result.overwritten.length)
+    console.log(`overwritten: ${result.overwritten.join(", ")}`);
+  if (result.skipped.length)
+    console.log(`already installed, skipped: ${result.skipped.join(", ")}`);
+  if (result.failed.length)
+    throw new Error(result.failed.map((f) => `${f.name}: ${f.error}`).join("; "));
+  return 0;
+}
+main().then((code) => {
+  process.exitCode = code;
+}).catch((error) => {
+  console.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
+  process.exitCode = 1;
+});