memroot 0.1.0-alpha.0

package/dist/index.js

@@ -0,0 +1,1703 @@
+#!/usr/bin/env node
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  try {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  } catch (e) {
+    throw mod = 0, e;
+  }
+};
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// ../../node_modules/.pnpm/sisteransi@1.0.5/node_modules/sisteransi/src/index.js
+var require_src = __commonJS({
+  "../../node_modules/.pnpm/sisteransi@1.0.5/node_modules/sisteransi/src/index.js"(exports, module) {
+    "use strict";
+    var ESC2 = "\x1B";
+    var CSI2 = `${ESC2}[`;
+    var beep = "\x07";
+    var cursor3 = {
+      to(x, y2) {
+        if (!y2) return `${CSI2}${x + 1}G`;
+        return `${CSI2}${y2 + 1};${x + 1}H`;
+      },
+      move(x, y2) {
+        let ret = "";
+        if (x < 0) ret += `${CSI2}${-x}D`;
+        else if (x > 0) ret += `${CSI2}${x}C`;
+        if (y2 < 0) ret += `${CSI2}${-y2}A`;
+        else if (y2 > 0) ret += `${CSI2}${y2}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 erase3 = {
+      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 i2 = 0; i2 < count; i2++)
+          clear += this.line + (i2 < count - 1 ? cursor3.up() : "");
+        if (count)
+          clear += cursor3.left;
+        return clear;
+      }
+    };
+    module.exports = { cursor: cursor3, scroll, erase: erase3, beep };
+  }
+});
+
+// ../../node_modules/.pnpm/@clack+core@1.5.0/node_modules/@clack/core/dist/index.mjs
+import { stdout, stdin } from "node:process";
+import l__default from "node:readline";
+
+// ../../node_modules/.pnpm/fast-string-truncated-width@3.0.3/node_modules/fast-string-truncated-width/dist/utils.js
+var getCodePointsLength = /* @__PURE__ */ (() => {
+  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/.pnpm/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 = new RegExp("[\\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 = new RegExp("\\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 i2 = 0, l = PARSE_BLOCKS.length; i2 < l; i2++) {
+      const [BLOCK_RE, BLOCK_WIDTH] = PARSE_BLOCKS[i2];
+      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/.pnpm/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/.pnpm/fast-wrap-ansi@0.2.2/node_modules/fast-wrap-ansi/lib/main.js
+var ESC = "\x1B";
+var CSI = "\x9B";
+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 void 0;
+};
+var wrapAnsiCode = (code) => `${ESC}${ANSI_CSI}${code}${ANSI_SGR_TERMINATOR}`;
+var wrapAnsiHyperlink = (url) => `${ESC}${ANSI_ESCAPE_LINK}${url}${ANSI_ESCAPE_BELL}`;
+var wrapWord = (rows2, word, columns) => {
+  const characters = word[Symbol.iterator]();
+  let isInsideEscape = false;
+  let isInsideLinkEscape = false;
+  let lastRow = rows2.at(-1);
+  let visible = lastRow === void 0 ? 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) {
+      rows2[rows2.length - 1] += character;
+    } else {
+      rows2.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) {
+        rows2.push("");
+        visible = 0;
+      }
+    }
+    currentCharacter = nextCharacter;
+    nextCharacter = characters.next();
+    rawCharacterIndex += character.length;
+  }
+  lastRow = rows2.at(-1);
+  if (!visible && lastRow !== void 0 && lastRow.length && rows2.length > 1) {
+    rows2[rows2.length - 2] += rows2.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 rows2 = [""];
+  let rowLength = 0;
+  for (let index = 0; index < words.length; index++) {
+    const word = words[index];
+    if (options.trim !== false) {
+      const row = rows2.at(-1) ?? "";
+      const trimmed = row.trimStart();
+      if (row.length !== trimmed.length) {
+        rows2[rows2.length - 1] = trimmed;
+        rowLength = dist_default2(trimmed);
+      }
+    }
+    if (index !== 0) {
+      if (rowLength >= columns && (options.wordWrap === false || options.trim === false)) {
+        rows2.push("");
+        rowLength = 0;
+      }
+      if (rowLength || options.trim === false) {
+        rows2[rows2.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) {
+        rows2.push("");
+      }
+      wrapWord(rows2, word, columns);
+      rowLength = dist_default2(rows2.at(-1) ?? "");
+      continue;
+    }
+    if (rowLength + wordLength > columns && rowLength && wordLength) {
+      if (options.wordWrap === false && rowLength < columns) {
+        wrapWord(rows2, word, columns);
+        rowLength = dist_default2(rows2.at(-1) ?? "");
+        continue;
+      }
+      rows2.push("");
+      rowLength = 0;
+    }
+    if (rowLength + wordLength > columns && options.wordWrap === false) {
+      wrapWord(rows2, word, columns);
+      rowLength = dist_default2(rows2.at(-1) ?? "");
+      continue;
+    }
+    rows2[rows2.length - 1] += word;
+    rowLength += wordLength;
+  }
+  if (options.trim !== false) {
+    rows2 = rows2.map((row) => stringVisibleTrimSpacesRight(row));
+  }
+  const preString = rows2.join("\n");
+  let inSurrogate = false;
+  for (let i2 = 0; i2 < preString.length; i2++) {
+    const character = preString[i2];
+    returnValue += character;
+    if (!inSurrogate) {
+      inSurrogate = character >= "\uD800" && character <= "\uDBFF";
+      if (inSurrogate) {
+        continue;
+      }
+    } else {
+      inSurrogate = false;
+    }
+    if (character === ESC || character === CSI) {
+      GROUP_REGEX.lastIndex = i2 + 1;
+      const groupsResult = GROUP_REGEX.exec(preString);
+      const groups = groupsResult?.groups;
+      if (groups?.code !== void 0) {
+        const code = Number.parseFloat(groups.code);
+        escapeCode = code === END_CODE ? void 0 : code;
+      } else if (groups?.uri !== void 0) {
+        escapeUrl = groups.uri.length === 0 ? void 0 : groups.uri;
+      }
+    }
+    if (preString[i2 + 1] === "\n") {
+      if (escapeUrl) {
+        returnValue += wrapAnsiHyperlink("");
+      }
+      const closingCode = escapeCode ? getClosingCode(escapeCode) : void 0;
+      if (escapeCode && closingCode) {
+        returnValue += wrapAnsiCode(closingCode);
+      }
+    } else if (character === "\n") {
+      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("\n");
+}
+
+// ../../node_modules/.pnpm/@clack+core@1.5.0/node_modules/@clack/core/dist/index.mjs
+var import_sisteransi = __toESM(require_src(), 1);
+function findCursor(s, o, l) {
+  if (!l.some((r2) => !r2.disabled))
+    return s;
+  const t2 = s + o, n2 = Math.max(l.length - 1, 0), e = t2 < 0 ? n2 : t2 > n2 ? 0 : t2;
+  return l[e]?.disabled ? findCursor(e, o < 0 ? -1 : 1, l) : 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([
+    // vim support
+    ["k", "up"],
+    ["j", "down"],
+    ["h", "left"],
+    ["l", "right"],
+    ["", "cancel"],
+    // opinionated defaults!
+    ["escape", "cancel"]
+  ]),
+  messages: {
+    cancel: "Canceled",
+    error: "Something went wrong"
+  },
+  withGuide: true,
+  accessible: void 0,
+  date: {
+    monthNames: [...t],
+    messages: {
+      required: "Please enter a valid date",
+      invalidMonth: "There are only 12 months in a year",
+      invalidDay: (n2, e) => `There are only ${n2} days in ${e}`,
+      afterMin: (n2) => `Date must be on or after ${n2.toISOString().slice(0, 10)}`,
+      beforeMax: (n2) => `Date must be on or before ${n2.toISOString().slice(0, 10)}`
+    }
+  }
+};
+function isAccessible(n2) {
+  if (n2 !== void 0) return n2;
+  if (settings.accessible !== void 0) return settings.accessible;
+  const e = process.env.ACCESSIBLE;
+  return e !== void 0 && e !== "" && e !== "0" && e !== "false";
+}
+function isActionKey(n2, e) {
+  if (typeof n2 == "string")
+    return settings.aliases.get(n2) === e;
+  for (const s of n2)
+    if (s !== void 0 && isActionKey(s, e))
+      return true;
+  return false;
+}
+function diffLines(i2, s) {
+  if (i2 === s) return;
+  const e = i2.split(`
+`), t2 = s.split(`
+`), r2 = Math.max(e.length, t2.length), f = [];
+  for (let n2 = 0; n2 < r2; n2++)
+    e[n2] !== t2[n2] && f.push(n2);
+  return {
+    lines: f,
+    numLinesBefore: e.length,
+    numLinesAfter: t2.length,
+    numLines: r2
+  };
+}
+var R = globalThis.process.platform.startsWith("win");
+var CANCEL_SYMBOL = /* @__PURE__ */ Symbol("clack:cancel");
+function isCancel(e) {
+  return e === CANCEL_SYMBOL;
+}
+function setRawMode(e, r2) {
+  const o = e;
+  o.isTTY && o.setRawMode(r2);
+}
+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, r2, o, n2 = o, s = o, t2) {
+  const f = getColumns(e ?? stdout);
+  return wrapAnsi(r2, f - o.length, {
+    hard: true,
+    trim: false
+  }).split(`
+`).map((c, i2, m2) => {
+    const d = t2 ? t2(c, i2) : c;
+    return i2 === 0 ? `${n2}${d}` : i2 === m2.length - 1 ? `${s}${d}` : `${o}${d}`;
+  }).join(`
+`);
+}
+function runValidation(e, a2) {
+  if ("~standard" in e) {
+    const n2 = e["~standard"].validate(a2);
+    return n2 instanceof Promise ? n2.then((r2) => r2.issues?.at(0)?.message) : n2.issues?.at(0)?.message;
+  }
+  return e(a2);
+}
+var y = class {
+  input;
+  output;
+  _abortSignal;
+  rl;
+  opts;
+  _render;
+  _track = false;
+  _prevFrame = "";
+  _subscribers = /* @__PURE__ */ new Map();
+  _cursor = 0;
+  state = "initial";
+  error = "";
+  value;
+  userInput = "";
+  /**
+   * Whether accessible (static, screen-reader friendly) output is enabled for
+   * this prompt, resolved from the `accessible` option, the global setting,
+   * and the `ACCESSIBLE` env var.
+   */
+  get accessible() {
+    return isAccessible(this.opts.accessible);
+  }
+  constructor(t2, e = true) {
+    const { input: i2 = stdin, output: s = stdout, render: r2, signal: n2, ...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 = r2.bind(this), this._track = e, this._abortSignal = n2, this.input = i2, this.output = s;
+  }
+  /**
+   * Unsubscribe all listeners
+   */
+  unsubscribe() {
+    this._subscribers.clear();
+  }
+  /**
+   * Set a subscriber with opts
+   * @param event - The event name
+   */
+  setSubscriber(t2, e) {
+    const i2 = this._subscribers.get(t2) ?? [];
+    i2.push(e), this._subscribers.set(t2, i2);
+  }
+  /**
+   * Subscribe to an event
+   * @param event - The event name
+   * @param cb - The callback
+   */
+  on(t2, e) {
+    this.setSubscriber(t2, { cb: e });
+  }
+  /**
+   * Subscribe to an event once
+   * @param event - The event name
+   * @param cb - The callback
+   */
+  once(t2, e) {
+    this.setSubscriber(t2, { cb: e, once: true });
+  }
+  /**
+   * Emit an event with data
+   * @param event - The event name
+   * @param data - The data to pass to the callback
+   */
+  emit(t2, ...e) {
+    const i2 = this._subscribers.get(t2) ?? [], s = [];
+    for (const r2 of i2)
+      r2.cb(...e), r2.once && s.push(() => i2.splice(i2.indexOf(r2), 1));
+    for (const r2 of s)
+      r2();
+  }
+  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 !== void 0 && 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 === "	";
+  }
+  _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("");
+  }
+  async onKeypress(t2, e) {
+    if (this.state !== "validating") {
+      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 i2 = runValidation(this.opts.validate, this.value);
+          let s;
+          i2 instanceof Promise ? (this.state = "validating", this.render(), s = await i2) : s = i2, s && (this.error = s instanceof Error ? s.message : s, 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 = void 0, 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), i2 = getRows(this.output);
+        if (this.restoreCursor(), e) {
+          const s = Math.max(0, e.numLinesAfter - i2), r2 = Math.max(0, e.numLinesBefore - i2);
+          let n2 = e.lines.find((o) => o >= s);
+          if (n2 === void 0) {
+            this._prevFrame = t2;
+            return;
+          }
+          if (e.lines.length === 1) {
+            this.output.write(import_sisteransi.cursor.move(0, n2 - r2)), this.output.write(import_sisteransi.erase.lines(1));
+            const o = t2.split(`
+`);
+            this.output.write(o[n2]), this._prevFrame = t2, this.output.write(import_sisteransi.cursor.move(0, o.length - n2 - 1));
+            return;
+          } else if (e.lines.length > 1) {
+            if (s < r2)
+              n2 = s;
+            else {
+              const h2 = n2 - r2;
+              h2 > 0 && this.output.write(import_sisteransi.cursor.move(0, h2));
+            }
+            this.output.write(import_sisteransi.erase.down());
+            const f = t2.split(`
+`).slice(n2);
+            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;
+    }
+  }
+};
+var r = class extends y {
+  get cursor() {
+    return this.value ? 0 : 1;
+  }
+  get _value() {
+    return this.cursor === 0;
+  }
+  constructor(t2) {
+    super(t2, false), this.value = !!t2.initialValue, this.on("userInput", () => {
+      this.value = this._value;
+    }), this.on("confirm", (i2) => {
+      this.output.write(import_sisteransi.cursor.move(0, -1)), this.value = i2, this.state = "submit", this.close();
+    }), this.on("cursor", () => {
+      this.value = !this.value;
+    });
+  }
+};
+var a = class extends y {
+  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, i2 = this.value !== void 0 && this.value.length === e.length;
+    this.value = i2 ? [] : e.map((t2) => t2.value);
+  }
+  toggleInvert() {
+    const e = this.value;
+    if (!e)
+      return;
+    const i2 = this._enabledOptions.filter((t2) => !e.includes(t2.value));
+    this.value = i2.map((t2) => t2.value);
+  }
+  toggleValue() {
+    this.value === void 0 && (this.value = []);
+    const e = this.value.includes(this._value);
+    this.value = e ? this.value.filter((i2) => i2 !== this._value) : [...this.value, this._value];
+  }
+  constructor(e) {
+    super(e, false), this.options = e.options, this.value = [...e.initialValues ?? []];
+    const i2 = Math.max(
+      this.options.findIndex(({ value: t2 }) => t2 === e.cursorAt),
+      0
+    );
+    this.cursor = this.options[i2]?.disabled ? findCursor(i2, 1, this.options) : i2, this.on("key", (t2, l) => {
+      l.name === "a" && this.toggleAll(), l.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;
+      }
+    });
+  }
+};
+
+// ../../node_modules/.pnpm/@clack+prompts@1.8.0/node_modules/@clack/prompts/dist/index.mjs
+import { styleText, 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 unicodeOr = (o, e) => unicode ? o : e;
+var S_STEP_ACTIVE = unicodeOr("\u25C6", "*");
+var S_STEP_CANCEL = unicodeOr("\u25A0", "x");
+var S_STEP_ERROR = unicodeOr("\u25B2", "x");
+var S_STEP_SUBMIT = unicodeOr("\u25C7", "o");
+var S_BAR_START = unicodeOr("\u250C", "T");
+var S_BAR = unicodeOr("\u2502", "|");
+var S_BAR_END = unicodeOr("\u2514", "\u2014");
+var S_BAR_START_RIGHT = unicodeOr("\u2510", "T");
+var S_BAR_END_RIGHT = unicodeOr("\u2518", "\u2014");
+var S_RADIO_ACTIVE = unicodeOr("\u25CF", ">");
+var S_RADIO_INACTIVE = unicodeOr("\u25CB", " ");
+var S_CHECKBOX_ACTIVE = unicodeOr("\u25FB", "[\u2022]");
+var S_CHECKBOX_SELECTED = unicodeOr("\u25FC", "[+]");
+var S_CHECKBOX_INACTIVE = unicodeOr("\u25FB", "[ ]");
+var S_PASSWORD_MASK = unicodeOr("\u25AA", "\u2022");
+var S_BAR_H = unicodeOr("\u2500", "-");
+var S_CORNER_TOP_RIGHT = unicodeOr("\u256E", "+");
+var S_CONNECT_LEFT = unicodeOr("\u251C", "+");
+var S_CORNER_BOTTOM_RIGHT = unicodeOr("\u256F", "+");
+var S_CORNER_BOTTOM_LEFT = unicodeOr("\u2570", "+");
+var S_CORNER_TOP_LEFT = unicodeOr("\u256D", "+");
+var S_INFO = unicodeOr("\u25CF", "\u2022");
+var S_SUCCESS = unicodeOr("\u25C6", "*");
+var S_WARN = unicodeOr("\u25B2", "!");
+var S_ERROR = unicodeOr("\u25A0", "x");
+var symbol = (o) => {
+  switch (o) {
+    case "initial":
+    case "active":
+      return styleText("cyan", S_STEP_ACTIVE);
+    case "cancel":
+      return styleText("red", S_STEP_CANCEL);
+    case "error":
+      return styleText("yellow", S_STEP_ERROR);
+    case "submit":
+      return styleText("green", S_STEP_SUBMIT);
+    case "validating":
+      return styleText("dim", S_STEP_ACTIVE);
+  }
+};
+var symbolBar = (o) => {
+  switch (o) {
+    case "initial":
+    case "active":
+      return styleText("cyan", S_BAR);
+    case "cancel":
+      return styleText("red", S_BAR);
+    case "error":
+      return styleText("yellow", S_BAR);
+    case "submit":
+      return styleText("green", S_BAR);
+  }
+};
+function formatInstructionFooter(o, e) {
+  const r2 = [`${e ? `${styleText("cyan", S_BAR)}  ` : ""}${o.join(" \u2022 ")}`];
+  return e && r2.push(styleText("cyan", S_BAR_END)), r2;
+}
+var I = (l, e, w, p, b, C2 = false) => {
+  let r2 = e, O = 0;
+  if (C2)
+    for (let i2 = p - 1; i2 >= w; i2--) {
+      const m2 = l[i2];
+      if (m2 && (r2 -= m2.length), O++, r2 <= b) break;
+    }
+  else
+    for (let i2 = w; i2 < p; i2++) {
+      const m2 = l[i2];
+      if (m2 && (r2 -= m2.length), O++, r2 <= b) break;
+    }
+  return { lineCount: r2, removals: O };
+};
+var limitOptions = ({
+  cursor: l,
+  options: e,
+  style: w,
+  output: p = process.stdout,
+  maxItems: b = Number.POSITIVE_INFINITY,
+  columnPadding: C2 = 0,
+  rowPadding: r2 = 4
+}) => {
+  const i2 = getColumns(p) - C2, m2 = getRows(p), M = styleText("dim", "..."), v = Math.max(m2 - r2, 0), a2 = Math.max(Math.min(b, v), 5);
+  let f = 0;
+  l >= a2 - 3 && (f = Math.max(
+    Math.min(l - 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), y2 = W - (c ? 1 : 0);
+  for (let t2 = T; t2 < y2; t2++) {
+    const n2 = e[t2], o = n2 ? w(n2, t2 === l) : "", h2 = wrapAnsi(o, i2, {
+      hard: true,
+      trim: false
+    }).split(`
+`);
+    s.push(h2), g += h2.length;
+  }
+  if (g > v) {
+    let t2 = 0, n2 = 0, o = g;
+    const h2 = l - T;
+    let u3 = v;
+    const L = () => I(s, o, 0, h2, u3), E = () => I(
+      s,
+      o,
+      h2 + 1,
+      s.length,
+      u3,
+      true
+    );
+    d ? ({ lineCount: o, removals: t2 } = L(), o > u3 && (c || (u3 -= 1), { lineCount: o, removals: n2 } = E())) : (c || (u3 -= 1), { lineCount: o, removals: n2 } = E(), o > u3 && (u3 -= 1, { lineCount: o, removals: t2 } = L())), t2 > 0 && (d = true, s.splice(0, t2)), n2 > 0 && (c = true, s.splice(s.length - n2, n2));
+  }
+  const x = [];
+  d && x.push(M);
+  for (const t2 of s)
+    for (const n2 of t2)
+      x.push(n2);
+  return c && x.push(M), x;
+};
+var confirm = (i2) => {
+  const a2 = i2.active ?? "Yes", s = i2.inactive ?? "No";
+  return new r({
+    active: a2,
+    inactive: s,
+    signal: i2.signal,
+    input: i2.input,
+    output: i2.output,
+    initialValue: i2.initialValue ?? true,
+    render() {
+      const e = i2.withGuide ?? settings.withGuide, u3 = `${symbol(this.state)}  `, l = e ? `${styleText("gray", S_BAR)}  ` : "", f = wrapTextWithPrefix(
+        i2.output,
+        i2.message,
+        l,
+        u3
+      ), o = `${e ? `${styleText("gray", S_BAR)}
+` : ""}${f}
+`, c = this.value ? a2 : s;
+      switch (this.state) {
+        case "submit": {
+          const r2 = e ? `${styleText("gray", S_BAR)}  ` : "";
+          return `${o}${r2}${styleText("dim", c)}`;
+        }
+        case "cancel": {
+          const r2 = e ? `${styleText("gray", S_BAR)}  ` : "";
+          return `${o}${r2}${styleText(["strikethrough", "dim"], c)}${e ? `
+${styleText("gray", S_BAR)}` : ""}`;
+        }
+        default: {
+          const r2 = e ? `${styleText("cyan", S_BAR)}  ` : "", g = e ? styleText("cyan", S_BAR_END) : "";
+          return `${o}${r2}${this.value ? `${styleText("green", S_RADIO_ACTIVE)} ${a2}` : `${styleText("dim", S_RADIO_INACTIVE)} ${styleText("dim", a2)}`}${i2.vertical ? e ? `
+${styleText("cyan", S_BAR)}  ` : `
+` : ` ${styleText("dim", "/")} `}${this.value ? `${styleText("dim", S_RADIO_INACTIVE)} ${styleText("dim", s)}` : `${styleText("green", S_RADIO_ACTIVE)} ${s}`}
+${g}
+`;
+        }
+      }
+    }
+  }).prompt();
+};
+var MULTISELECT_INSTRUCTIONS = [
+  `${styleText("dim", "\u2191/\u2193")} to navigate`,
+  `${styleText("dim", "Space:")} select`,
+  `${styleText("dim", "Enter:")} confirm`
+];
+var m = (i2, u3) => i2.split(`
+`).map((d) => u3(d)).join(`
+`);
+var multiselect = (i2) => {
+  const u3 = (t2, a2) => {
+    const r2 = t2.label ?? String(t2.value);
+    return a2 === "disabled" ? `${styleText("gray", S_CHECKBOX_INACTIVE)} ${m(r2, (o) => styleText(["strikethrough", "gray"], o))}${t2.hint ? ` ${styleText("dim", `(${t2.hint ?? "disabled"})`)}` : ""}` : a2 === "active" ? `${styleText("cyan", S_CHECKBOX_ACTIVE)} ${r2}${t2.hint ? ` ${styleText("dim", `(${t2.hint})`)}` : ""}` : a2 === "selected" ? `${styleText("green", S_CHECKBOX_SELECTED)} ${m(r2, (o) => styleText("dim", o))}${t2.hint ? ` ${styleText("dim", `(${t2.hint})`)}` : ""}` : a2 === "cancelled" ? `${m(r2, (o) => styleText(["strikethrough", "dim"], o))}` : a2 === "active-selected" ? `${styleText("green", S_CHECKBOX_SELECTED)} ${r2}${t2.hint ? ` ${styleText("dim", `(${t2.hint})`)}` : ""}` : a2 === "submitted" ? `${m(r2, (o) => styleText("dim", o))}` : `${styleText("dim", S_CHECKBOX_INACTIVE)} ${m(r2, (o) => styleText("dim", o))}`;
+  }, d = i2.required ?? true, v = i2.showInstructions ?? true;
+  return new a({
+    options: i2.options,
+    signal: i2.signal,
+    input: i2.input,
+    output: i2.output,
+    initialValues: i2.initialValues,
+    required: d,
+    cursorAt: i2.cursorAt,
+    validate(t2) {
+      if (d && (t2 === void 0 || t2.length === 0))
+        return `Please select at least one option.
+${styleText(
+          "reset",
+          styleText(
+            "dim",
+            `Press ${styleText(["gray", "bgWhite", "inverse"], " space ")} to select, ${styleText(
+              "gray",
+              styleText("bgWhite", styleText("inverse", " enter "))
+            )} to submit`
+          )
+        )}`;
+    },
+    render() {
+      const t2 = i2.withGuide ?? settings.withGuide, a2 = wrapTextWithPrefix(
+        i2.output,
+        i2.message,
+        t2 ? `${symbolBar(this.state)}  ` : "",
+        `${symbol(this.state)}  `
+      ), r2 = `${t2 ? `${styleText("gray", S_BAR)}
+` : ""}${a2}
+`, o = this.value ?? [], p = (n2, l) => {
+        if (n2.disabled)
+          return u3(n2, "disabled");
+        const s = o.includes(n2.value);
+        return l && s ? u3(n2, "active-selected") : s ? u3(n2, "selected") : u3(n2, l ? "active" : "inactive");
+      };
+      switch (this.state) {
+        case "submit": {
+          const n2 = this.options.filter(({ value: s }) => o.includes(s)).map((s) => u3(s, "submitted")).join(styleText("dim", ", ")) || styleText("dim", "none"), l = wrapTextWithPrefix(
+            i2.output,
+            n2,
+            t2 ? `${styleText("gray", S_BAR)}  ` : ""
+          );
+          return `${r2}${l}`;
+        }
+        case "cancel": {
+          const n2 = this.options.filter(({ value: s }) => o.includes(s)).map((s) => u3(s, "cancelled")).join(styleText("dim", ", "));
+          if (n2.trim() === "")
+            return `${r2}${styleText("gray", S_BAR)}`;
+          const l = wrapTextWithPrefix(
+            i2.output,
+            n2,
+            t2 ? `${styleText("gray", S_BAR)}  ` : ""
+          );
+          return `${r2}${l}${t2 ? `
+${styleText("gray", S_BAR)}` : ""}`;
+        }
+        case "error": {
+          const n2 = t2 ? `${styleText("yellow", S_BAR)}  ` : "", l = this.error.split(`
+`).map(
+            ($, C2) => C2 === 0 ? `${t2 ? `${styleText("yellow", S_BAR_END)}  ` : ""}${styleText("yellow", $)}` : `   ${$}`
+          ).join(`
+`), s = r2.split(`
+`).length, h2 = l.split(`
+`).length + 1;
+          return `${r2}${n2}${limitOptions({
+            output: i2.output,
+            options: this.options,
+            cursor: this.cursor,
+            maxItems: i2.maxItems,
+            columnPadding: n2.length,
+            rowPadding: s + h2,
+            style: p
+          }).join(`
+${n2}`)}
+${l}
+`;
+        }
+        default: {
+          const n2 = t2 ? `${styleText("cyan", S_BAR)}  ` : "", l = r2.split(`
+`).length, s = v ? formatInstructionFooter(MULTISELECT_INSTRUCTIONS, t2) : t2 ? [styleText("cyan", S_BAR_END)] : [], h2 = s.join(`
+`), $ = s.length + 1;
+          return `${r2}${n2}${limitOptions({
+            output: i2.output,
+            options: this.options,
+            cursor: this.cursor,
+            maxItems: i2.maxItems,
+            columnPadding: n2.length,
+            rowPadding: l + $,
+            style: p
+          }).join(`
+${n2}`)}
+${h2}
+`;
+        }
+      }
+    }
+  }).prompt();
+};
+var cancel = (o = "", t2) => {
+  const i2 = t2?.output ?? process.stdout, e = t2?.withGuide ?? settings.withGuide ? `${styleText("gray", S_BAR_END)}  ` : "";
+  i2.write(`${e}${styleText("red", o)}
+
+`);
+};
+var intro = (o = "", t2) => {
+  const i2 = t2?.output ?? process.stdout, e = t2?.withGuide ?? settings.withGuide ? `${styleText("gray", S_BAR_START)}  ` : "";
+  i2.write(`${e}${o}
+`);
+};
+var outro = (o = "", t2) => {
+  const i2 = t2?.output ?? process.stdout, e = t2?.withGuide ?? settings.withGuide ? `${styleText("gray", S_BAR)}
+${styleText("gray", S_BAR_END)}  ` : "";
+  i2.write(`${e}${o}
+
+`);
+};
+var W$1 = (o) => o;
+var C = (o, e, s) => {
+  const a2 = {
+    hard: true,
+    trim: false
+  }, i2 = wrapAnsi(o, e, a2).split(`
+`), c = i2.reduce((n2, t2) => Math.max(dist_default2(t2), n2), 0), u3 = i2.map(s).reduce((n2, t2) => Math.max(dist_default2(t2), n2), 0), g = e - (u3 - c);
+  return wrapAnsi(o, g, a2);
+};
+var note = (o = "", e = "", s) => {
+  const a2 = s?.output ?? process$1.stdout, i2 = s?.withGuide ?? settings.withGuide, c = s?.format ?? W$1, g = ["", ...C(o, getColumns(a2) - 6, c).split(`
+`).map(c), ""], n2 = dist_default2(e), t2 = Math.max(
+    g.reduce((m2, F) => {
+      const O = dist_default2(F);
+      return O > m2 ? O : m2;
+    }, 0),
+    n2
+  ) + 2, h2 = g.map(
+    (m2) => `${styleText("gray", S_BAR)}  ${m2}${" ".repeat(t2 - dist_default2(m2))}${styleText("gray", S_BAR)}`
+  ).join(`
+`), T = i2 ? `${styleText("gray", S_BAR)}
+` : "", l$1 = i2 ? S_CONNECT_LEFT : S_CORNER_BOTTOM_LEFT;
+  a2.write(
+    `${T}${styleText("green", S_STEP_SUBMIT)}  ${styleText("reset", e)} ${styleText(
+      "gray",
+      S_BAR_H.repeat(Math.max(t2 - n2 - 1, 1)) + S_CORNER_TOP_RIGHT
+    )}
+${h2}
+${styleText("gray", l$1 + S_BAR_H.repeat(t2 + 2) + S_CORNER_BOTTOM_RIGHT)}
+`
+  );
+};
+var u2 = {
+  light: unicodeOr("\u2500", "-"),
+  heavy: unicodeOr("\u2501", "="),
+  block: unicodeOr("\u2588", "#")
+};
+var SELECT_INSTRUCTIONS = [
+  `${styleText("dim", "\u2191/\u2193")} to navigate`,
+  `${styleText("dim", "Enter:")} confirm`
+];
+var i = `${styleText("gray", S_BAR)}  `;
+
+// src/native.ts
+import { spawnSync } from "node:child_process";
+import { accessSync, constants, realpathSync, statSync } from "node:fs";
+import { delimiter, isAbsolute, join } from "node:path";
+import { stripVTControlCharacters as stripVTControlCharacters2 } from "node:util";
+var agents = ["claude", "codex", "grok"];
+var labels = {
+  claude: "Claude Code",
+  codex: "Codex",
+  grok: "Grok"
+};
+function executable(agent) {
+  for (const directory of (process.env.PATH ?? "").split(delimiter)) {
+    if (!isAbsolute(directory)) continue;
+    for (const extension of [""]) {
+      const path = join(directory, agent + extension);
+      try {
+        accessSync(path, constants.X_OK);
+        if (statSync(path).isFile()) return path;
+      } catch {
+      }
+    }
+  }
+  return void 0;
+}
+function native(path, agent, args) {
+  const result = spawnSync(path, args, {
+    encoding: "utf8",
+    timeout: 6e4,
+    maxBuffer: 4 * 1024 * 1024,
+    shell: false
+  });
+  if (result.error || result.status !== 0) {
+    throw new Error(
+      `NATIVE_COMMAND_FAILED: ${agent} ${args.slice(0, 3).join(" ")} failed (${result.status ?? result.error?.code ?? "signal"}). Check '${agent} plugin --help', update the agent CLI, and retry. Its plugin manager may have partially registered Memroot; no success receipt was written.`
+    );
+  }
+  return result.stdout;
+}
+function installCommands(agent, marketplace) {
+  if (agent === "claude")
+    return [
+      ["plugin", "marketplace", "add", marketplace, "--scope", "user"],
+      ["plugin", "install", "memroot@memroot", "--scope", "user"]
+    ];
+  if (agent === "codex")
+    return [
+      ["plugin", "marketplace", "add", marketplace, "--json"],
+      ["plugin", "add", "memroot@memroot", "--json"]
+    ];
+  return [
+    ["plugin", "install", join(marketplace, "plugins", "memroot"), "--trust"]
+  ];
+}
+function preflight(path, agent) {
+  native(path, agent, ["plugin", "--help"]);
+  if (agent !== "grok")
+    native(path, agent, ["plugin", "marketplace", "add", "--help"]);
+  native(path, agent, [
+    "plugin",
+    agent === "codex" ? "add" : "install",
+    "--help"
+  ]);
+}
+function rows(output, field) {
+  let value;
+  try {
+    value = JSON.parse(output);
+  } catch {
+    throw new Error(
+      "NATIVE_STATUS_UNSUPPORTED: Agent plugin status is not valid JSON. Update the agent CLI and retry."
+    );
+  }
+  if (field)
+    value = value && typeof value === "object" ? value[field] : void 0;
+  if (!Array.isArray(value) || value.some((row) => !row || typeof row !== "object" || Array.isArray(row)))
+    throw new Error(
+      "NATIVE_STATUS_UNSUPPORTED: Unrecognized agent plugin status; refusing to change it."
+    );
+  return value;
+}
+function samePath(left, right) {
+  if (typeof left !== "string") return false;
+  try {
+    return realpathSync(left) === realpathSync(right);
+  } catch {
+    return left === right;
+  }
+}
+function inspectNative(path, agent, marketplace, previousMarketplace) {
+  if (agent === "grok") {
+    const output = stripVTControlCharacters2(
+      native(path, agent, ["plugin", "list"])
+    );
+    const lines = output.split("\n").filter((line) => line.trim());
+    const empty = output.trim() === "No plugins installed. Run `grok plugin install --help` to get started.";
+    if (!empty && (!lines.length || lines.some(
+      (line) => !/^\s*\S+:\s+[^[]+\[.+\](?:\s+\(disabled\))?\s*$/.test(line)
+    ))) {
+      throw new Error(
+        "NATIVE_STATUS_UNSUPPORTED: Unrecognized Grok plugin list format. Update Grok and inspect its native plugin manager before retrying."
+      );
+    }
+    const matching = output.split("\n").filter((line) => /:\s*memroot(?:\s|$)/.test(line));
+    for (const line of matching) {
+      const source = line.match(/\[local: (.*)\]/)?.[1];
+      if (!samePath(source, join(marketplace, "plugins", "memroot")) && !(previousMarketplace && samePath(source, join(previousMarketplace, "plugins", "memroot"))))
+        throw new Error(
+          "PLUGIN_COLLISION: Grok already has a different Memroot plugin. Resolve it with the native plugin manager first."
+        );
+      if (/disabled/i.test(line))
+        throw new Error(
+          "PLUGIN_DISABLED: Memroot is disabled in Grok. Enable it in the native plugin manager when ready."
+        );
+    }
+    return { registered: false, installed: matching.length > 0 };
+  }
+  const markets = rows(
+    native(path, agent, ["plugin", "marketplace", "list", "--json"]),
+    agent === "codex" ? "marketplaces" : void 0
+  );
+  const plugins = rows(
+    native(path, agent, ["plugin", "list", "--json"]),
+    agent === "codex" ? "installed" : void 0
+  );
+  const matchingMarkets = markets.filter((row) => row.name === "memroot");
+  for (const market of matchingMarkets) {
+    const source = agent === "codex" ? market.root : market.path;
+    if (!samePath(source, marketplace) && !(previousMarketplace && samePath(source, previousMarketplace)))
+      throw new Error(
+        "MARKETPLACE_COLLISION: memroot is already registered from a different source. Resolve it with the native plugin manager first."
+      );
+  }
+  const matchingPlugins = plugins.filter(
+    (row) => row.id === "memroot@memroot" || row.pluginId === "memroot@memroot" || row.name === "memroot"
+  );
+  if (matchingPlugins.length && !matchingMarkets.length)
+    throw new Error(
+      "PLUGIN_COLLISION: An existing Memroot plugin has no matching managed marketplace. Resolve it with the native plugin manager first."
+    );
+  for (const plugin of matchingPlugins) {
+    if (plugin.enabled === false)
+      throw new Error(
+        `PLUGIN_DISABLED: Memroot is disabled in ${labels[agent]}. Enable it in the native plugin manager when ready; setup preserves your choice.`
+      );
+    if (plugin.enabled !== true || agent === "claude" && plugin.scope !== "user")
+      throw new Error(
+        "PLUGIN_COLLISION: Existing Memroot plugin status or scope cannot be safely managed. Check the native plugin manager."
+      );
+  }
+  return {
+    registered: matchingMarkets.length > 0,
+    installed: matchingPlugins.length > 0
+  };
+}
+
+// src/storage.ts
+import { createHash, randomUUID } from "node:crypto";
+import {
+  cp,
+  lstat,
+  mkdir,
+  readdir,
+  readFile,
+  rename,
+  rm,
+  writeFile
+} from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, isAbsolute as isAbsolute2, join as join2 } from "node:path";
+import { fileURLToPath } from "node:url";
+var version = "0.1.0-alpha.0";
+function dataDirectory() {
+  const base = process.platform === "win32" ? process.env.LOCALAPPDATA ?? join2(homedir(), "AppData", "Local") : process.env.XDG_DATA_HOME ?? join2(homedir(), ".local", "share");
+  if (!isAbsolute2(base))
+    throw new Error(
+      "INVALID_DATA_DIRECTORY: XDG_DATA_HOME or LOCALAPPDATA must be absolute."
+    );
+  return join2(base, "memroot");
+}
+async function exists(path) {
+  try {
+    await lstat(path);
+    return true;
+  } catch (error) {
+    if (error.code === "ENOENT") return false;
+    throw error;
+  }
+}
+async function safeDirectory(path) {
+  const boundary = dataDirectory();
+  if (path !== boundary && path.startsWith(`${boundary}/`))
+    await safeDirectory(dirname(path));
+  await mkdir(path, { recursive: true, mode: 448 });
+  const info = await lstat(path);
+  if (!info.isDirectory() || info.isSymbolicLink())
+    throw new Error(`UNSAFE_PATH: Expected a real directory at ${path}.`);
+}
+async function fileEntries(root, prefix = "") {
+  const directory = await lstat(join2(root, prefix));
+  if (!directory.isDirectory() || directory.isSymbolicLink())
+    throw new Error(
+      "INTEGRITY_ERROR: Managed plugin directory is not a real directory."
+    );
+  const result = [];
+  for (const name of (await readdir(join2(root, prefix))).sort()) {
+    const path = join2(root, prefix, name);
+    const info = await lstat(path);
+    const key = join2(prefix, name);
+    if (info.isSymbolicLink())
+      throw new Error(
+        "INTEGRITY_ERROR: Plugin assets must not contain symbolic links."
+      );
+    if (info.isDirectory()) result.push(...await fileEntries(root, key));
+    else if (info.isFile()) result.push([key, await readFile(path)]);
+    else throw new Error("INTEGRITY_ERROR: Unsupported plugin asset.");
+  }
+  return result;
+}
+async function integrity(root) {
+  const hash = createHash("sha256");
+  for (const [name, bytes] of await fileEntries(root))
+    hash.update(name).update("\0").update(String(bytes.length)).update("\0").update(bytes);
+  return hash.digest("hex");
+}
+async function readReceipt(data, agent) {
+  const path = join2(data, "receipts", `${agent}.json`);
+  if (!await exists(path)) return void 0;
+  if (!(await lstat(path)).isFile() || (await lstat(path)).isSymbolicLink())
+    throw new Error("INVALID_RECEIPT: Expected a regular receipt file.");
+  const value = JSON.parse(await readFile(path, "utf8"));
+  if (!value || typeof value !== "object")
+    throw new Error("INVALID_RECEIPT: Cannot safely read installer state.");
+  const receipt = value;
+  if (receipt.schemaVersion !== 1 || receipt.agent !== agent || typeof receipt.version !== "string" || !/^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/.test(
+    receipt.version
+  ) || typeof receipt.integrity !== "string" || !/^[a-f0-9]{64}$/.test(receipt.integrity) || receipt.marketplace !== join2(data, "releases", receipt.version, agent))
+    throw new Error("INVALID_RECEIPT: Cannot safely read installer state.");
+  return receipt;
+}
+async function verifyReceipt(receipt) {
+  if (await integrity(receipt.marketplace) !== receipt.integrity)
+    throw new Error(
+      "INTEGRITY_ERROR: Managed plugin files were modified. Preserve your changes and reinstall from a clean managed directory."
+    );
+}
+async function writeReceipt(data, receipt) {
+  await safeDirectory(join2(data, "receipts"));
+  const path = join2(data, "receipts", `${receipt.agent}.json`);
+  const temporary = `${path}.${randomUUID()}.tmp`;
+  try {
+    await writeFile(temporary, `${JSON.stringify(receipt, null, 2)}
+`, {
+      flag: "wx",
+      mode: 384
+    });
+    await rename(temporary, path);
+  } finally {
+    await rm(temporary, { force: true });
+  }
+}
+function marketplaceMetadata(agent) {
+  if (agent === "codex")
+    return {
+      path: ".agents/plugins/marketplace.json",
+      value: {
+        name: "memroot",
+        interface: { displayName: "Memroot" },
+        plugins: [
+          {
+            name: "memroot",
+            source: { source: "local", path: "./plugins/memroot" },
+            policy: { installation: "AVAILABLE", authentication: "ON_USE" },
+            category: "Productivity"
+          }
+        ]
+      }
+    };
+  return {
+    path: ".claude-plugin/marketplace.json",
+    value: {
+      name: "memroot",
+      owner: { name: "Memroot" },
+      plugins: [
+        {
+          name: "memroot",
+          source: "./plugins/memroot",
+          description: "Memroot integration readiness and status",
+          version
+        }
+      ]
+    }
+  };
+}
+async function stage(data, agent) {
+  const releases = join2(data, "releases", version);
+  await safeDirectory(releases);
+  const target = join2(releases, agent);
+  const temporary = join2(releases, `.${agent}-${randomUUID()}`);
+  const source = fileURLToPath(new URL(`./plugins/${agent}/`, import.meta.url));
+  await fileEntries(source);
+  try {
+    await mkdir(join2(temporary, "plugins"), { recursive: true, mode: 448 });
+    await cp(source, join2(temporary, "plugins", "memroot"), {
+      recursive: true,
+      dereference: false
+    });
+    if (agent !== "grok") {
+      const metadata = marketplaceMetadata(agent);
+      await mkdir(dirname(join2(temporary, metadata.path)), { recursive: true });
+      await writeFile(
+        join2(temporary, metadata.path),
+        `${JSON.stringify(metadata.value, null, 2)}
+`
+      );
+    }
+    const digest = await integrity(temporary);
+    if (await exists(target)) {
+      if (await integrity(target) !== digest)
+        throw new Error(
+          "INTEGRITY_ERROR: Existing versioned plugin files differ from this package; refusing to overwrite."
+        );
+    } else await rename(temporary, target);
+    return {
+      schemaVersion: 1,
+      agent,
+      version,
+      marketplace: target,
+      integrity: digest
+    };
+  } finally {
+    await rm(temporary, { recursive: true, force: true });
+  }
+}
+async function acquireLock(data) {
+  await safeDirectory(data);
+  const lock = join2(data, ".setup-lock");
+  try {
+    await mkdir(lock, { mode: 448 });
+  } catch (error) {
+    if (error.code === "EEXIST")
+      throw new Error(
+        `SETUP_BUSY: Another setup owns ${lock}. Wait for it to finish. If it was interrupted, verify no memroot setup process remains before removing that lock directory.`
+      );
+    throw error;
+  }
+  await writeFile(
+    join2(lock, "owner.json"),
+    JSON.stringify({ pid: process.pid, createdAt: (/* @__PURE__ */ new Date()).toISOString() }),
+    { mode: 384 }
+  );
+  return async () => {
+    await rm(lock, { recursive: true });
+  };
+}
+
+// src/index.ts
+var installationDocs = {
+  claude: "https://code.claude.com/docs/en/quickstart",
+  codex: "https://developers.openai.com/codex/cli",
+  grok: "https://docs.x.ai/build/overview"
+};
+var setupComplete = "Plugins ready. Cloud memory is not connected.";
+var cloudStatus = "Cloud memory: not connected. This installer alpha does not provide cloud authentication, memory retrieval, or session upload.";
+var help = `Memroot ${version} \u2014 native agent plugin installer
+
+Usage:
+  npx memroot setup
+  memroot setup --agent codex --yes
+  memroot setup --agent claude --agent grok --yes --dry-run
+  memroot doctor
+
+Commands:
+  setup       Install native plugins for your user account
+  doctor      Check installer receipts and plugin file integrity
+
+Options:
+  --agent     claude, codex, or grok; repeat to select more than one
+  --yes       Use the explicitly selected agents without interactive prompts
+  --dry-run   Show planned changes without running agent CLIs or writing files
+  --help      Show help
+  --version   Show version
+
+${cloudStatus}
+Grok setup trusts the selected local plugin via its native --trust option.
+Hook execution trust remains controlled by each agent.
+`;
+function parse(args) {
+  const command = args.shift();
+  if (command !== "setup" && command !== "doctor")
+    throw new Error(
+      "INVALID_ARGUMENT: Choose setup or doctor. Run memroot --help."
+    );
+  const options = { command, selected: [], yes: false, dryRun: false };
+  while (args.length) {
+    const flag = args.shift();
+    if (flag === "--yes") options.yes = true;
+    else if (flag === "--dry-run") options.dryRun = true;
+    else if (flag === "--agent") {
+      const value = args.shift();
+      if (!agents.includes(value))
+        throw new Error("INVALID_AGENT: Use claude, codex, or grok.");
+      if (!options.selected.includes(value))
+        options.selected.push(value);
+    } else
+      throw new Error(
+        `INVALID_ARGUMENT: Unknown option ${flag}. Run memroot --help.`
+      );
+  }
+  if (command === "doctor" && (options.yes || options.dryRun))
+    throw new Error("INVALID_ARGUMENT: doctor supports only --agent.");
+  return options;
+}
+async function doctor(selected) {
+  const data = dataDirectory();
+  let failures = 0;
+  for (const agent of selected.length ? selected : agents) {
+    const path = executable(agent);
+    try {
+      const receipt = await readReceipt(data, agent);
+      if (!receipt) {
+        console.log(
+          `${labels[agent]}: no installation receipt; CLI ${path ? "detected" : "not found"}.`
+        );
+        continue;
+      }
+      await verifyReceipt(receipt);
+      if (path) {
+        const state = inspectNative(path, agent, receipt.marketplace);
+        if (!state.installed)
+          throw new Error(
+            "PLUGIN_MISSING: Native plugin installation is absent. Run memroot setup again."
+          );
+      }
+      console.log(
+        `${labels[agent]}: plugin files verified (${receipt.version}); CLI ${path ? "detected" : "not found"}. ${path ? "Native plugin present" : "Native presence not verified"}; hook execution trust remains controlled by the agent.`
+      );
+      if (!path) failures++;
+    } catch (error) {
+      failures++;
+      console.error(
+        `${labels[agent]}: ${error instanceof Error ? error.message : "check failed"}`
+      );
+    }
+  }
+  console.log(cloudStatus);
+  if (failures) process.exitCode = 1;
+}
+async function setup(options) {
+  if (process.platform !== "darwin" && process.platform !== "linux")
+    throw new Error(
+      "UNSUPPORTED_PLATFORM: This installer alpha supports macOS and Linux. Windows support is not available yet."
+    );
+  const found = new Map(agents.map((agent) => [agent, executable(agent)]));
+  const interactive = Boolean(
+    process.stdin.isTTY && process.stdout.isTTY && !options.yes && !options.dryRun
+  );
+  if (interactive) {
+    intro(`Memroot ${version}`);
+    note(
+      "Install Memroot plugins for your coding agents.\nCloud memory connection is not available in this alpha.",
+      "Set up your agents"
+    );
+    if (!options.selected.length) {
+      const result = await multiselect({
+        message: "Choose agents (Space to select, Enter to continue)",
+        required: true,
+        options: agents.map((agent) => ({
+          value: agent,
+          label: labels[agent],
+          hint: found.get(agent) ? "CLI detected" : "CLI not found"
+        })),
+        initialValues: agents.filter((agent) => found.get(agent))
+      });
+      if (isCancel(result)) {
+        cancel("Setup cancelled. No changes made.");
+        return;
+      }
+      options.selected = result;
+    }
+  }
+  if (!options.selected.length)
+    throw new Error(
+      "AGENT_REQUIRED: Choose an agent with --agent codex (repeat for multiple agents). Use --yes for noninteractive setup."
+    );
+  for (const agent of options.selected)
+    if (!found.get(agent))
+      throw new Error(
+        `AGENT_NOT_FOUND: ${labels[agent]} CLI is not on PATH. Install it from ${installationDocs[agent]}, then retry memroot setup --agent ${agent} --yes.`
+      );
+  if (!interactive && !options.yes && !options.dryRun)
+    throw new Error(
+      "CONFIRMATION_REQUIRED: Noninteractive setup requires --yes with explicit --agent selections."
+    );
+  const data = dataDirectory();
+  const summary = `${options.selected.map((agent) => labels[agent]).join(", ")}
+User scope \xB7 ${data}
+${options.selected.includes("grok") ? "Grok: trust this local Memroot plugin using native --trust.\n" : ""}${cloudStatus}`;
+  if (options.dryRun) {
+    console.log(`Dry run \u2014 no changes
+${summary}`);
+    for (const agent of options.selected)
+      console.log(
+        `${agent}: ${JSON.stringify(installCommands(agent, `${data}/releases/${version}/${agent}`))}`
+      );
+    return;
+  }
+  if (interactive) {
+    note(summary, "Installation");
+    const confirmed = await confirm({
+      message: "Install these plugins?",
+      initialValue: true
+    });
+    if (isCancel(confirmed) || !confirmed) {
+      cancel("Setup cancelled. No changes made.");
+      return;
+    }
+  } else console.log(summary);
+  for (const agent of options.selected)
+    preflight(found.get(agent), agent);
+  const release = await acquireLock(data);
+  try {
+    for (const agent of options.selected) {
+      const receipt = await readReceipt(data, agent);
+      if (receipt) await verifyReceipt(receipt);
+      const candidate = await stage(data, agent);
+      const state = inspectNative(
+        found.get(agent),
+        agent,
+        candidate.marketplace,
+        receipt?.marketplace
+      );
+      if (state.installed && receipt?.version === candidate.version && receipt.integrity === candidate.integrity) {
+        console.log(
+          `${labels[agent]}: already installed; plugin files verified. Check native enablement in the agent.`
+        );
+        continue;
+      }
+      const commands = installCommands(agent, candidate.marketplace);
+      if (state.registered && (!receipt || receipt.marketplace === candidate.marketplace))
+        commands.shift();
+      for (const args of commands)
+        native(found.get(agent), agent, args);
+      await writeReceipt(data, candidate);
+      console.log(
+        `${labels[agent]}: plugin installed. Restart the agent to load it.`
+      );
+    }
+  } finally {
+    await release();
+  }
+  if (interactive) outro(setupComplete);
+  else console.log(setupComplete);
+}
+async function main() {
+  const args = process.argv.slice(2);
+  if (args.includes("--help") || args.length === 0) {
+    console.log(help);
+    return;
+  }
+  if (args.length === 1 && args[0] === "--version") {
+    console.log(version);
+    return;
+  }
+  const options = parse(args);
+  if (options.command === "doctor") await doctor(options.selected);
+  else await setup(options);
+}
+main().catch((error) => {
+  console.error(
+    error instanceof Error ? error.message : "SETUP_FAILED: Unexpected installer failure."
+  );
+  process.exitCode = 1;
+});