zapdev 0.4.0 → 0.6.0

package/dist/cli.js

@@ -0,0 +1,2786 @@
+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 (e2) {
+    throw mod = 0, e2;
+  }
+};
+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/sisteransi/src/index.js
+var require_src = __commonJS({
+  "node_modules/sisteransi/src/index.js"(exports, module) {
+    "use strict";
+    var ESC2 = "\x1B";
+    var CSI2 = `${ESC2}[`;
+    var beep = "\x07";
+    var cursor3 = {
+      to(x2, y2) {
+        if (!y2) return `${CSI2}${x2 + 1}G`;
+        return `${CSI2}${y2 + 1};${x2 + 1}H`;
+      },
+      move(x2, y2) {
+        let ret = "";
+        if (x2 < 0) ret += `${CSI2}${-x2}D`;
+        else if (x2 > 0) ret += `${CSI2}${x2}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 i3 = 0; i3 < count; i3++)
+          clear += this.line + (i3 < count - 1 ? cursor3.up() : "");
+        if (count)
+          clear += cursor3.left;
+        return clear;
+      }
+    };
+    module.exports = { cursor: cursor3, scroll, erase: erase3, beep };
+  }
+});
+
+// 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/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 = (x2) => {
+  return x2 === 12288 || x2 >= 65281 && x2 <= 65376 || x2 >= 65504 && x2 <= 65510;
+};
+var isWideNotCJKTNotEmoji = (x2) => {
+  return x2 === 8987 || x2 === 9001 || x2 >= 12272 && x2 <= 12287 || x2 >= 12289 && x2 <= 12350 || x2 >= 12441 && x2 <= 12543 || x2 >= 12549 && x2 <= 12591 || x2 >= 12593 && x2 <= 12686 || x2 >= 12688 && x2 <= 12771 || x2 >= 12783 && x2 <= 12830 || x2 >= 12832 && x2 <= 12871 || x2 >= 12880 && x2 <= 19903 || x2 >= 65040 && x2 <= 65049 || x2 >= 65072 && x2 <= 65106 || x2 >= 65108 && x2 <= 65126 || x2 >= 65128 && x2 <= 65131 || x2 >= 127488 && x2 <= 127490 || x2 >= 127504 && x2 <= 127547 || x2 >= 127552 && x2 <= 127560 || x2 >= 131072 && x2 <= 196605 || x2 >= 196608 && x2 <= 262141;
+};
+
+// 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 i3 = 0, l3 = PARSE_BLOCKS.length; i3 < l3; i3++) {
+      const [BLOCK_RE, BLOCK_WIDTH] = PARSE_BLOCKS[i3];
+      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/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/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 = (rows, word, columns) => {
+  const characters = word[Symbol.iterator]();
+  let isInsideEscape = false;
+  let isInsideLinkEscape = false;
+  let lastRow = rows.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) {
+      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 !== void 0 && 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("\n");
+  let inSurrogate = false;
+  for (let i3 = 0; i3 < preString.length; i3++) {
+    const character = preString[i3];
+    returnValue += character;
+    if (!inSurrogate) {
+      inSurrogate = character >= "\uD800" && character <= "\uDBFF";
+      if (inSurrogate) {
+        continue;
+      }
+    } else {
+      inSurrogate = false;
+    }
+    if (character === ESC || character === CSI) {
+      GROUP_REGEX.lastIndex = i3 + 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[i3 + 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/@clack/core/dist/index.mjs
+var import_sisteransi = __toESM(require_src(), 1);
+import { ReadStream } from "node:tty";
+function findCursor(s2, o2, l3) {
+  if (!l3.some((r3) => !r3.disabled))
+    return s2;
+  const t3 = s2 + o2, n4 = Math.max(l3.length - 1, 0), e2 = t3 < 0 ? n4 : t3 > n4 ? 0 : t3;
+  return l3[e2]?.disabled ? findCursor(e2, o2 < 0 ? -1 : 1, l3) : e2;
+}
+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,
+  date: {
+    monthNames: [...t],
+    messages: {
+      required: "Please enter a valid date",
+      invalidMonth: "There are only 12 months in a year",
+      invalidDay: (n4, e2) => `There are only ${n4} days in ${e2}`,
+      afterMin: (n4) => `Date must be on or after ${n4.toISOString().slice(0, 10)}`,
+      beforeMax: (n4) => `Date must be on or before ${n4.toISOString().slice(0, 10)}`
+    }
+  }
+};
+function isActionKey(n4, e2) {
+  if (typeof n4 == "string")
+    return settings.aliases.get(n4) === e2;
+  for (const s2 of n4)
+    if (s2 !== void 0 && isActionKey(s2, e2))
+      return true;
+  return false;
+}
+function diffLines(i3, s2) {
+  if (i3 === s2) return;
+  const e2 = i3.split(`
+`), t3 = s2.split(`
+`), r3 = Math.max(e2.length, t3.length), f2 = [];
+  for (let n4 = 0; n4 < r3; n4++)
+    e2[n4] !== t3[n4] && f2.push(n4);
+  return {
+    lines: f2,
+    numLinesBefore: e2.length,
+    numLinesAfter: t3.length,
+    numLines: r3
+  };
+}
+var R = globalThis.process.platform.startsWith("win");
+var CANCEL_SYMBOL = /* @__PURE__ */ Symbol("clack:cancel");
+function isCancel(e2) {
+  return e2 === CANCEL_SYMBOL;
+}
+function setRawMode(e2, r3) {
+  const o2 = e2;
+  o2.isTTY && o2.setRawMode(r3);
+}
+function block({
+  input: e2 = stdin,
+  output: r3 = stdout,
+  overwrite: o2 = true,
+  hideCursor: t3 = true
+} = {}) {
+  const s2 = l.createInterface({
+    input: e2,
+    output: r3,
+    prompt: "",
+    tabSize: 1
+  });
+  l.emitKeypressEvents(e2, s2), e2 instanceof ReadStream && e2.isTTY && e2.setRawMode(true);
+  const n4 = (f2, { name: a3, sequence: p2 }) => {
+    const c3 = String(f2);
+    if (isActionKey([c3, a3, p2], "cancel")) {
+      t3 && r3.write(import_sisteransi.cursor.show), process.exit(0);
+      return;
+    }
+    if (!o2) return;
+    const i3 = a3 === "return" ? 0 : -1, m3 = a3 === "return" ? -1 : 0;
+    l.moveCursor(r3, i3, m3, () => {
+      l.clearLine(r3, 1, () => {
+        e2.once("keypress", n4);
+      });
+    });
+  };
+  return t3 && r3.write(import_sisteransi.cursor.hide), e2.once("keypress", n4), () => {
+    e2.off("keypress", n4), t3 && r3.write(import_sisteransi.cursor.show), e2 instanceof ReadStream && e2.isTTY && !R && e2.setRawMode(false), s2.terminal = false, s2.close();
+  };
+}
+var getColumns = (e2) => "columns" in e2 && typeof e2.columns == "number" ? e2.columns : 80;
+var getRows = (e2) => "rows" in e2 && typeof e2.rows == "number" ? e2.rows : 20;
+function wrapTextWithPrefix(e2, r3, o2, t3 = o2, s2 = o2, n4) {
+  const f2 = getColumns(e2 ?? stdout);
+  return wrapAnsi(r3, f2 - o2.length, {
+    hard: true,
+    trim: false
+  }).split(`
+`).map((c3, i3, m3) => {
+    const d2 = n4 ? n4(c3, i3) : c3;
+    return i3 === 0 ? `${t3}${d2}` : i3 === m3.length - 1 ? `${s2}${d2}` : `${o2}${d2}`;
+  }).join(`
+`);
+}
+function runValidation(e2, n4) {
+  if ("~standard" in e2) {
+    const a3 = e2["~standard"].validate(n4);
+    if (a3 instanceof Promise)
+      throw new TypeError(
+        "Schema validation must be synchronous. Update `validate()` and remove any asynchronous logic."
+      );
+    return a3.issues?.at(0)?.message;
+  }
+  return e2(n4);
+}
+var V = class {
+  input;
+  output;
+  _abortSignal;
+  rl;
+  opts;
+  _render;
+  _track = false;
+  _prevFrame = "";
+  _subscribers = /* @__PURE__ */ new Map();
+  _cursor = 0;
+  state = "initial";
+  error = "";
+  value;
+  userInput = "";
+  constructor(t3, e2 = true) {
+    const { input: i3 = stdin, output: n4 = stdout, render: s2, signal: r3, ...o2 } = t3;
+    this.opts = o2, this.onKeypress = this.onKeypress.bind(this), this.close = this.close.bind(this), this.render = this.render.bind(this), this._render = s2.bind(this), this._track = e2, this._abortSignal = r3, this.input = i3, this.output = n4;
+  }
+  /**
+   * Unsubscribe all listeners
+   */
+  unsubscribe() {
+    this._subscribers.clear();
+  }
+  /**
+   * Set a subscriber with opts
+   * @param event - The event name
+   */
+  setSubscriber(t3, e2) {
+    const i3 = this._subscribers.get(t3) ?? [];
+    i3.push(e2), this._subscribers.set(t3, i3);
+  }
+  /**
+   * Subscribe to an event
+   * @param event - The event name
+   * @param cb - The callback
+   */
+  on(t3, e2) {
+    this.setSubscriber(t3, { cb: e2 });
+  }
+  /**
+   * Subscribe to an event once
+   * @param event - The event name
+   * @param cb - The callback
+   */
+  once(t3, e2) {
+    this.setSubscriber(t3, { cb: e2, once: true });
+  }
+  /**
+   * Emit an event with data
+   * @param event - The event name
+   * @param data - The data to pass to the callback
+   */
+  emit(t3, ...e2) {
+    const i3 = this._subscribers.get(t3) ?? [], n4 = [];
+    for (const s2 of i3)
+      s2.cb(...e2), s2.once && n4.push(() => i3.splice(i3.indexOf(s2), 1));
+    for (const s2 of n4)
+      s2();
+  }
+  prompt() {
+    return new Promise((t3) => {
+      if (this._abortSignal) {
+        if (this._abortSignal.aborted)
+          return this.state = "cancel", this.close(), t3(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), t3(this.value);
+      }), this.once("cancel", () => {
+        this.output.write(import_sisteransi.cursor.show), this.output.off("resize", this.render), setRawMode(this.input, false), t3(CANCEL_SYMBOL);
+      });
+    });
+  }
+  _isActionKey(t3, e2) {
+    return t3 === "	";
+  }
+  _shouldSubmit(t3, e2) {
+    return true;
+  }
+  _setValue(t3) {
+    this.value = t3, this.emit("value", this.value);
+  }
+  _setUserInput(t3, e2) {
+    this.userInput = t3 ?? "", this.emit("userInput", this.userInput), e2 && 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(t3, e2) {
+    if (this._track && e2.name !== "return" && (e2.name && this._isActionKey(t3, e2) && 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"), e2?.name && (!this._track && settings.aliases.has(e2.name) && this.emit("cursor", settings.aliases.get(e2.name)), settings.actions.has(e2.name) && this.emit("cursor", e2.name)), t3 && (t3.toLowerCase() === "y" || t3.toLowerCase() === "n") && this.emit("confirm", t3.toLowerCase() === "y"), this.emit("key", t3, e2), e2?.name === "return" && this._shouldSubmit(t3, e2)) {
+      if (this.opts.validate) {
+        const i3 = runValidation(this.opts.validate, this.value);
+        i3 && (this.error = i3 instanceof Error ? i3.message : i3, this.state = "error", this.rl?.write(this.userInput));
+      }
+      this.state !== "error" && (this.state = "submit");
+    }
+    isActionKey([t3, e2?.name, e2?.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 t3 = wrapAnsi(this._prevFrame, process.stdout.columns, { hard: true, trim: false }).split(`
+`).length - 1;
+    this.output.write(import_sisteransi.cursor.move(-999, t3 * -1));
+  }
+  render() {
+    const t3 = wrapAnsi(this._render(this) ?? "", process.stdout.columns, {
+      hard: true,
+      trim: false
+    });
+    if (t3 !== this._prevFrame) {
+      if (this.state === "initial")
+        this.output.write(import_sisteransi.cursor.hide);
+      else {
+        const e2 = diffLines(this._prevFrame, t3), i3 = getRows(this.output);
+        if (this.restoreCursor(), e2) {
+          const n4 = Math.max(0, e2.numLinesAfter - i3), s2 = Math.max(0, e2.numLinesBefore - i3);
+          let r3 = e2.lines.find((o2) => o2 >= n4);
+          if (r3 === void 0) {
+            this._prevFrame = t3;
+            return;
+          }
+          if (e2.lines.length === 1) {
+            this.output.write(import_sisteransi.cursor.move(0, r3 - s2)), this.output.write(import_sisteransi.erase.lines(1));
+            const o2 = t3.split(`
+`);
+            this.output.write(o2[r3]), this._prevFrame = t3, this.output.write(import_sisteransi.cursor.move(0, o2.length - r3 - 1));
+            return;
+          } else if (e2.lines.length > 1) {
+            if (n4 < s2)
+              r3 = n4;
+            else {
+              const h3 = r3 - s2;
+              h3 > 0 && this.output.write(import_sisteransi.cursor.move(0, h3));
+            }
+            this.output.write(import_sisteransi.erase.down());
+            const f2 = t3.split(`
+`).slice(r3);
+            this.output.write(f2.join(`
+`)), this._prevFrame = t3;
+            return;
+          }
+        }
+        this.output.write(import_sisteransi.erase.down());
+      }
+      this.output.write(t3), this.state === "initial" && (this.state = "active"), this._prevFrame = t3;
+    }
+  }
+};
+var r = class extends V {
+  get cursor() {
+    return this.value ? 0 : 1;
+  }
+  get _value() {
+    return this.cursor === 0;
+  }
+  constructor(t3) {
+    super(t3, false), this.value = !!t3.initialValue, this.on("userInput", () => {
+      this.value = this._value;
+    }), this.on("confirm", (i3) => {
+      this.output.write(import_sisteransi.cursor.move(0, -1)), this.value = i3, this.state = "submit", this.close();
+    }), this.on("cursor", () => {
+      this.value = !this.value;
+    });
+  }
+};
+var a = class extends V {
+  options;
+  cursor = 0;
+  get _value() {
+    return this.options[this.cursor]?.value;
+  }
+  get _enabledOptions() {
+    return this.options.filter((e2) => e2.disabled !== true);
+  }
+  toggleAll() {
+    const e2 = this._enabledOptions, i3 = this.value !== void 0 && this.value.length === e2.length;
+    this.value = i3 ? [] : e2.map((t3) => t3.value);
+  }
+  toggleInvert() {
+    const e2 = this.value;
+    if (!e2)
+      return;
+    const i3 = this._enabledOptions.filter((t3) => !e2.includes(t3.value));
+    this.value = i3.map((t3) => t3.value);
+  }
+  toggleValue() {
+    this.value === void 0 && (this.value = []);
+    const e2 = this.value.includes(this._value);
+    this.value = e2 ? this.value.filter((i3) => i3 !== this._value) : [...this.value, this._value];
+  }
+  constructor(e2) {
+    super(e2, false), this.options = e2.options, this.value = [...e2.initialValues ?? []];
+    const i3 = Math.max(
+      this.options.findIndex(({ value: t3 }) => t3 === e2.cursorAt),
+      0
+    );
+    this.cursor = this.options[i3]?.disabled ? findCursor(i3, 1, this.options) : i3, this.on("key", (t3, l3) => {
+      l3.name === "a" && this.toggleAll(), l3.name === "i" && this.toggleInvert();
+    }), this.on("cursor", (t3) => {
+      switch (t3) {
+        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 e2 = this._selectedValue;
+    this.value = e2 === void 0 ? void 0 : e2.value;
+  }
+  constructor(e2) {
+    super(e2, false), this.options = e2.options;
+    const o2 = this.options.findIndex(({ value: s2 }) => s2 === e2.initialValue), t3 = o2 === -1 ? 0 : o2;
+    this.cursor = this.options[t3]?.disabled ? findCursor(t3, 1, this.options) : t3, this.changeValue(), this.on("cursor", (s2) => {
+      switch (s2) {
+        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();
+    });
+  }
+};
+var n2 = class extends V {
+  get userInputWithCursor() {
+    if (this.state === "submit")
+      return this.userInput;
+    const t3 = this.userInput;
+    if (this.cursor >= t3.length)
+      return `${this.userInput}\u2588`;
+    const r3 = t3.slice(0, this.cursor), s2 = t3.slice(this.cursor, this.cursor + 1), e2 = t3.slice(this.cursor + 1);
+    return `${r3}${styleText("inverse", s2)}${e2}`;
+  }
+  get cursor() {
+    return this._cursor;
+  }
+  constructor(t3) {
+    super({
+      ...t3,
+      initialUserInput: t3.initialUserInput ?? t3.initialValue
+    }), this.on("userInput", (r3) => {
+      this._setValue(r3);
+    }), this.on("finalize", () => {
+      this.value || (this.value = t3.defaultValue), this.value === void 0 && (this.value = "");
+    });
+  }
+};
+
+// 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 = (o2, e2) => unicode ? o2 : e2;
+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 = (o2) => {
+  switch (o2) {
+    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 = (o2) => {
+  switch (o2) {
+    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(o2, e2) {
+  const r3 = [`${e2 ? `${styleText2("cyan", S_BAR)}  ` : ""}${o2.join(" \u2022 ")}`];
+  return e2 && r3.push(styleText2("cyan", S_BAR_END)), r3;
+}
+var I = (l3, e2, w2, p2, b2, C2 = false) => {
+  let r3 = e2, O2 = 0;
+  if (C2)
+    for (let i3 = p2 - 1; i3 >= w2; i3--) {
+      const m3 = l3[i3];
+      if (m3 && (r3 -= m3.length), O2++, r3 <= b2) break;
+    }
+  else
+    for (let i3 = w2; i3 < p2; i3++) {
+      const m3 = l3[i3];
+      if (m3 && (r3 -= m3.length), O2++, r3 <= b2) break;
+    }
+  return { lineCount: r3, removals: O2 };
+};
+var limitOptions = ({
+  cursor: l3,
+  options: e2,
+  style: w2,
+  output: p2 = process.stdout,
+  maxItems: b2 = Number.POSITIVE_INFINITY,
+  columnPadding: C2 = 0,
+  rowPadding: r3 = 4
+}) => {
+  const i3 = getColumns(p2) - C2, m3 = getRows(p2), M = styleText2("dim", "..."), v2 = Math.max(m3 - r3, 0), a3 = Math.max(Math.min(b2, v2), 5);
+  let f2 = 0;
+  l3 >= a3 - 3 && (f2 = Math.max(
+    Math.min(l3 - a3 + 3, e2.length - a3),
+    0
+  ));
+  let d2 = a3 < e2.length && f2 > 0, c3 = a3 < e2.length && f2 + a3 < e2.length;
+  const W2 = Math.min(
+    f2 + a3,
+    e2.length
+  ), s2 = [];
+  let g2 = 0;
+  d2 && g2++, c3 && g2++;
+  const T2 = f2 + (d2 ? 1 : 0), y2 = W2 - (c3 ? 1 : 0);
+  for (let t3 = T2; t3 < y2; t3++) {
+    const n4 = e2[t3], o2 = n4 ? w2(n4, t3 === l3) : "", h3 = wrapAnsi(o2, i3, {
+      hard: true,
+      trim: false
+    }).split(`
+`);
+    s2.push(h3), g2 += h3.length;
+  }
+  if (g2 > v2) {
+    let t3 = 0, n4 = 0, o2 = g2;
+    const h3 = l3 - T2;
+    let u4 = v2;
+    const L = () => I(s2, o2, 0, h3, u4), E2 = () => I(
+      s2,
+      o2,
+      h3 + 1,
+      s2.length,
+      u4,
+      true
+    );
+    d2 ? ({ lineCount: o2, removals: t3 } = L(), o2 > u4 && (c3 || (u4 -= 1), { lineCount: o2, removals: n4 } = E2())) : (c3 || (u4 -= 1), { lineCount: o2, removals: n4 } = E2(), o2 > u4 && (u4 -= 1, { lineCount: o2, removals: t3 } = L())), t3 > 0 && (d2 = true, s2.splice(0, t3)), n4 > 0 && (c3 = true, s2.splice(s2.length - n4, n4));
+  }
+  const x2 = [];
+  d2 && x2.push(M);
+  for (const t3 of s2)
+    for (const n4 of t3)
+      x2.push(n4);
+  return c3 && x2.push(M), x2;
+};
+var confirm = (i3) => {
+  const a3 = i3.active ?? "Yes", s2 = i3.inactive ?? "No";
+  return new r({
+    active: a3,
+    inactive: s2,
+    signal: i3.signal,
+    input: i3.input,
+    output: i3.output,
+    initialValue: i3.initialValue ?? true,
+    render() {
+      const e2 = i3.withGuide ?? settings.withGuide, u4 = `${symbol(this.state)}  `, l3 = e2 ? `${styleText2("gray", S_BAR)}  ` : "", f2 = wrapTextWithPrefix(
+        i3.output,
+        i3.message,
+        l3,
+        u4
+      ), o2 = `${e2 ? `${styleText2("gray", S_BAR)}
+` : ""}${f2}
+`, c3 = this.value ? a3 : s2;
+      switch (this.state) {
+        case "submit": {
+          const r3 = e2 ? `${styleText2("gray", S_BAR)}  ` : "";
+          return `${o2}${r3}${styleText2("dim", c3)}`;
+        }
+        case "cancel": {
+          const r3 = e2 ? `${styleText2("gray", S_BAR)}  ` : "";
+          return `${o2}${r3}${styleText2(["strikethrough", "dim"], c3)}${e2 ? `
+${styleText2("gray", S_BAR)}` : ""}`;
+        }
+        default: {
+          const r3 = e2 ? `${styleText2("cyan", S_BAR)}  ` : "", g2 = e2 ? styleText2("cyan", S_BAR_END) : "";
+          return `${o2}${r3}${this.value ? `${styleText2("green", S_RADIO_ACTIVE)} ${a3}` : `${styleText2("dim", S_RADIO_INACTIVE)} ${styleText2("dim", a3)}`}${i3.vertical ? e2 ? `
+${styleText2("cyan", S_BAR)}  ` : `
+` : ` ${styleText2("dim", "/")} `}${this.value ? `${styleText2("dim", S_RADIO_INACTIVE)} ${styleText2("dim", s2)}` : `${styleText2("green", S_RADIO_ACTIVE)} ${s2}`}
+${g2}
+`;
+        }
+      }
+    }
+  }).prompt();
+};
+var MULTISELECT_INSTRUCTIONS = [
+  `${styleText2("dim", "\u2191/\u2193")} to navigate`,
+  `${styleText2("dim", "Space:")} select`,
+  `${styleText2("dim", "Enter:")} confirm`
+];
+var m = (i3, u4) => i3.split(`
+`).map((d2) => u4(d2)).join(`
+`);
+var multiselect = (i3) => {
+  const u4 = (t3, a3) => {
+    const r3 = t3.label ?? String(t3.value);
+    return a3 === "disabled" ? `${styleText2("gray", S_CHECKBOX_INACTIVE)} ${m(r3, (o2) => styleText2(["strikethrough", "gray"], o2))}${t3.hint ? ` ${styleText2("dim", `(${t3.hint ?? "disabled"})`)}` : ""}` : a3 === "active" ? `${styleText2("cyan", S_CHECKBOX_ACTIVE)} ${r3}${t3.hint ? ` ${styleText2("dim", `(${t3.hint})`)}` : ""}` : a3 === "selected" ? `${styleText2("green", S_CHECKBOX_SELECTED)} ${m(r3, (o2) => styleText2("dim", o2))}${t3.hint ? ` ${styleText2("dim", `(${t3.hint})`)}` : ""}` : a3 === "cancelled" ? `${m(r3, (o2) => styleText2(["strikethrough", "dim"], o2))}` : a3 === "active-selected" ? `${styleText2("green", S_CHECKBOX_SELECTED)} ${r3}${t3.hint ? ` ${styleText2("dim", `(${t3.hint})`)}` : ""}` : a3 === "submitted" ? `${m(r3, (o2) => styleText2("dim", o2))}` : `${styleText2("dim", S_CHECKBOX_INACTIVE)} ${m(r3, (o2) => styleText2("dim", o2))}`;
+  }, d2 = i3.required ?? true, v2 = i3.showInstructions ?? true;
+  return new a({
+    options: i3.options,
+    signal: i3.signal,
+    input: i3.input,
+    output: i3.output,
+    initialValues: i3.initialValues,
+    required: d2,
+    cursorAt: i3.cursorAt,
+    validate(t3) {
+      if (d2 && (t3 === void 0 || t3.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 t3 = i3.withGuide ?? settings.withGuide, a3 = wrapTextWithPrefix(
+        i3.output,
+        i3.message,
+        t3 ? `${symbolBar(this.state)}  ` : "",
+        `${symbol(this.state)}  `
+      ), r3 = `${t3 ? `${styleText2("gray", S_BAR)}
+` : ""}${a3}
+`, o2 = this.value ?? [], p2 = (n4, l3) => {
+        if (n4.disabled)
+          return u4(n4, "disabled");
+        const s2 = o2.includes(n4.value);
+        return l3 && s2 ? u4(n4, "active-selected") : s2 ? u4(n4, "selected") : u4(n4, l3 ? "active" : "inactive");
+      };
+      switch (this.state) {
+        case "submit": {
+          const n4 = this.options.filter(({ value: s2 }) => o2.includes(s2)).map((s2) => u4(s2, "submitted")).join(styleText2("dim", ", ")) || styleText2("dim", "none"), l3 = wrapTextWithPrefix(
+            i3.output,
+            n4,
+            t3 ? `${styleText2("gray", S_BAR)}  ` : ""
+          );
+          return `${r3}${l3}`;
+        }
+        case "cancel": {
+          const n4 = this.options.filter(({ value: s2 }) => o2.includes(s2)).map((s2) => u4(s2, "cancelled")).join(styleText2("dim", ", "));
+          if (n4.trim() === "")
+            return `${r3}${styleText2("gray", S_BAR)}`;
+          const l3 = wrapTextWithPrefix(
+            i3.output,
+            n4,
+            t3 ? `${styleText2("gray", S_BAR)}  ` : ""
+          );
+          return `${r3}${l3}${t3 ? `
+${styleText2("gray", S_BAR)}` : ""}`;
+        }
+        case "error": {
+          const n4 = t3 ? `${styleText2("yellow", S_BAR)}  ` : "", l3 = this.error.split(`
+`).map(
+            ($, C2) => C2 === 0 ? `${t3 ? `${styleText2("yellow", S_BAR_END)}  ` : ""}${styleText2("yellow", $)}` : `   ${$}`
+          ).join(`
+`), s2 = r3.split(`
+`).length, h3 = l3.split(`
+`).length + 1;
+          return `${r3}${n4}${limitOptions({
+            output: i3.output,
+            options: this.options,
+            cursor: this.cursor,
+            maxItems: i3.maxItems,
+            columnPadding: n4.length,
+            rowPadding: s2 + h3,
+            style: p2
+          }).join(`
+${n4}`)}
+${l3}
+`;
+        }
+        default: {
+          const n4 = t3 ? `${styleText2("cyan", S_BAR)}  ` : "", l3 = r3.split(`
+`).length, s2 = v2 ? formatInstructionFooter(MULTISELECT_INSTRUCTIONS, t3) : t3 ? [styleText2("cyan", S_BAR_END)] : [], h3 = s2.join(`
+`), $ = s2.length + 1;
+          return `${r3}${n4}${limitOptions({
+            output: i3.output,
+            options: this.options,
+            cursor: this.cursor,
+            maxItems: i3.maxItems,
+            columnPadding: n4.length,
+            rowPadding: l3 + $,
+            style: p2
+          }).join(`
+${n4}`)}
+${h3}
+`;
+        }
+      }
+    }
+  }).prompt();
+};
+var log = {
+  message: (s2 = [], {
+    symbol: e2 = styleText2("gray", S_BAR),
+    secondarySymbol: r3 = styleText2("gray", S_BAR),
+    output: m3 = process.stdout,
+    spacing: l3 = 1,
+    withGuide: c3
+  } = {}) => {
+    const t3 = [], o2 = c3 ?? settings.withGuide, f2 = o2 ? r3 : "", O2 = o2 ? `${e2}  ` : "", u4 = o2 ? `${r3}  ` : "";
+    for (let i3 = 0; i3 < l3; i3++)
+      t3.push(f2);
+    const g2 = Array.isArray(s2) ? s2 : s2.split(`
+`);
+    if (g2.length > 0) {
+      const [i3, ...y2] = g2;
+      i3.length > 0 ? t3.push(`${O2}${i3}`) : t3.push(o2 ? e2 : "");
+      for (const p2 of y2)
+        p2.length > 0 ? t3.push(`${u4}${p2}`) : t3.push(o2 ? r3 : "");
+    }
+    m3.write(`${t3.join(`
+`)}
+`);
+  },
+  info: (s2, e2) => {
+    log.message(s2, { ...e2, symbol: styleText2("blue", S_INFO) });
+  },
+  success: (s2, e2) => {
+    log.message(s2, { ...e2, symbol: styleText2("green", S_SUCCESS) });
+  },
+  step: (s2, e2) => {
+    log.message(s2, { ...e2, symbol: styleText2("green", S_STEP_SUBMIT) });
+  },
+  warn: (s2, e2) => {
+    log.message(s2, { ...e2, symbol: styleText2("yellow", S_WARN) });
+  },
+  /** alias for `log.warn()`. */
+  warning: (s2, e2) => {
+    log.warn(s2, e2);
+  },
+  error: (s2, e2) => {
+    log.message(s2, { ...e2, symbol: styleText2("red", S_ERROR) });
+  }
+};
+var cancel = (o2 = "", t3) => {
+  const i3 = t3?.output ?? process.stdout, e2 = t3?.withGuide ?? settings.withGuide ? `${styleText2("gray", S_BAR_END)}  ` : "";
+  i3.write(`${e2}${styleText2("red", o2)}
+
+`);
+};
+var intro = (o2 = "", t3) => {
+  const i3 = t3?.output ?? process.stdout, e2 = t3?.withGuide ?? settings.withGuide ? `${styleText2("gray", S_BAR_START)}  ` : "";
+  i3.write(`${e2}${o2}
+`);
+};
+var outro = (o2 = "", t3) => {
+  const i3 = t3?.output ?? process.stdout, e2 = t3?.withGuide ?? settings.withGuide ? `${styleText2("gray", S_BAR)}
+${styleText2("gray", S_BAR_END)}  ` : "";
+  i3.write(`${e2}${o2}
+
+`);
+};
+var W = (l3) => styleText2("magenta", l3);
+var spinner = ({
+  indicator: l3 = "dots",
+  onCancel: h3,
+  output: n4 = process.stdout,
+  cancelMessage: G,
+  errorMessage: O2,
+  frames: E2 = unicode ? ["\u25D2", "\u25D0", "\u25D3", "\u25D1"] : ["\u2022", "o", "O", "0"],
+  delay: F2 = unicode ? 80 : 120,
+  signal: m3,
+  ...I3
+} = {}) => {
+  const u4 = isCI();
+  let M, T2, d2 = false, S2 = false, s2 = "", p2, w2 = performance.now();
+  const x2 = getColumns(n4), k2 = I3?.styleFrame ?? W, g2 = (e2) => {
+    const r3 = e2 > 1 ? O2 ?? settings.messages.error : G ?? settings.messages.cancel;
+    S2 = e2 === 1, d2 && (a3(r3, e2), S2 && typeof h3 == "function" && h3());
+  }, f2 = () => g2(2), i3 = () => g2(1), A = () => {
+    process.on("uncaughtExceptionMonitor", f2), process.on("unhandledRejection", f2), process.on("SIGINT", i3), process.on("SIGTERM", i3), process.on("exit", g2), m3 && m3.addEventListener("abort", i3);
+  }, H = () => {
+    process.removeListener("uncaughtExceptionMonitor", f2), process.removeListener("unhandledRejection", f2), process.removeListener("SIGINT", i3), process.removeListener("SIGTERM", i3), process.removeListener("exit", g2), m3 && m3.removeEventListener("abort", i3);
+  }, y2 = () => {
+    if (p2 === void 0) return;
+    u4 && n4.write(`
+`);
+    const r3 = wrapAnsi(p2, x2, {
+      hard: true,
+      trim: false
+    }).split(`
+`);
+    r3.length > 1 && n4.write(import_sisteransi2.cursor.up(r3.length - 1)), n4.write(import_sisteransi2.cursor.to(0)), n4.write(import_sisteransi2.erase.down());
+  }, C2 = (e2) => e2.replace(/\.+$/, ""), _2 = (e2) => {
+    const r3 = (performance.now() - e2) / 1e3, t3 = Math.floor(r3 / 60), o2 = Math.floor(r3 % 60);
+    return t3 > 0 ? `[${t3}m ${o2}s]` : `[${o2}s]`;
+  }, N2 = I3.withGuide ?? settings.withGuide, P2 = (e2 = "") => {
+    d2 = true, M = block({ output: n4 }), s2 = C2(e2), w2 = performance.now(), N2 && n4.write(`${styleText2("gray", S_BAR)}
+`);
+    let r3 = 0, t3 = 0;
+    A(), T2 = setInterval(() => {
+      if (u4 && s2 === p2)
+        return;
+      y2(), p2 = s2;
+      const o2 = k2(E2[r3]);
+      let v2;
+      if (u4)
+        v2 = `${o2}  ${s2}...`;
+      else if (l3 === "timer")
+        v2 = `${o2}  ${s2} ${_2(w2)}`;
+      else {
+        const B = ".".repeat(Math.floor(t3)).slice(0, 3);
+        v2 = `${o2}  ${s2}${B}`;
+      }
+      const j2 = wrapAnsi(v2, x2, {
+        hard: true,
+        trim: false
+      });
+      n4.write(j2), r3 = r3 + 1 < E2.length ? r3 + 1 : 0, t3 = t3 < 4 ? t3 + 0.125 : 0;
+    }, F2);
+  }, a3 = (e2 = "", r3 = 0, t3 = false) => {
+    if (!d2) return;
+    d2 = false, clearInterval(T2), y2();
+    const o2 = r3 === 0 ? styleText2("green", S_STEP_SUBMIT) : r3 === 1 ? styleText2("red", S_STEP_CANCEL) : styleText2("red", S_STEP_ERROR);
+    s2 = e2 ?? s2, t3 || (l3 === "timer" ? n4.write(`${o2}  ${s2} ${_2(w2)}
+`) : n4.write(`${o2}  ${s2}
+`)), H(), M();
+  };
+  return {
+    start: P2,
+    stop: (e2 = "") => a3(e2, 0),
+    message: (e2 = "") => {
+      s2 = C2(e2 ?? s2);
+    },
+    cancel: (e2 = "") => a3(e2, 1),
+    error: (e2 = "") => a3(e2, 2),
+    clear: () => a3("", 0, true),
+    get isCancelled() {
+      return S2;
+    }
+  };
+};
+var u2 = {
+  light: unicodeOr("\u2500", "-"),
+  heavy: unicodeOr("\u2501", "="),
+  block: unicodeOr("\u2588", "#")
+};
+var SELECT_INSTRUCTIONS = [
+  `${styleText2("dim", "\u2191/\u2193")} to navigate`,
+  `${styleText2("dim", "Enter:")} confirm`
+];
+var c = (t3, o2) => t3.includes(`
+`) ? t3.split(`
+`).map((d2) => o2(d2)).join(`
+`) : o2(t3);
+var select = (t3) => {
+  const o2 = (n4, m3) => {
+    if (n4 === void 0)
+      return "";
+    const s2 = n4.label ?? String(n4.value);
+    switch (m3) {
+      case "disabled":
+        return `${styleText2("gray", S_RADIO_INACTIVE)} ${c(s2, (i3) => styleText2("gray", i3))}${n4.hint ? ` ${styleText2("dim", `(${n4.hint ?? "disabled"})`)}` : ""}`;
+      case "selected":
+        return `${c(s2, (i3) => styleText2("dim", i3))}`;
+      case "active":
+        return `${styleText2("green", S_RADIO_ACTIVE)} ${s2}${n4.hint ? ` ${styleText2("dim", `(${n4.hint})`)}` : ""}`;
+      case "cancelled":
+        return `${c(s2, (i3) => styleText2(["strikethrough", "dim"], i3))}`;
+      default:
+        return `${styleText2("dim", S_RADIO_INACTIVE)} ${c(s2, (i3) => styleText2("dim", i3))}`;
+    }
+  }, d2 = t3.showInstructions ?? true;
+  return new n$1({
+    options: t3.options,
+    signal: t3.signal,
+    input: t3.input,
+    output: t3.output,
+    initialValue: t3.initialValue,
+    render() {
+      const n4 = t3.withGuide ?? settings.withGuide, m3 = `${symbol(this.state)}  `, s2 = `${symbolBar(this.state)}  `, i3 = wrapTextWithPrefix(
+        t3.output,
+        t3.message,
+        s2,
+        m3
+      ), u4 = `${n4 ? `${styleText2("gray", S_BAR)}
+` : ""}${i3}
+`;
+      switch (this.state) {
+        case "submit": {
+          const r3 = n4 ? `${styleText2("gray", S_BAR)}  ` : "", a3 = wrapTextWithPrefix(
+            t3.output,
+            o2(this.options[this.cursor], "selected"),
+            r3
+          );
+          return `${u4}${a3}`;
+        }
+        case "cancel": {
+          const r3 = n4 ? `${styleText2("gray", S_BAR)}  ` : "", a3 = wrapTextWithPrefix(
+            t3.output,
+            o2(this.options[this.cursor], "cancelled"),
+            r3
+          );
+          return `${u4}${a3}${n4 ? `
+${styleText2("gray", S_BAR)}` : ""}`;
+        }
+        default: {
+          const r3 = n4 ? `${styleText2("cyan", S_BAR)}  ` : "", a3 = u4.split(`
+`).length, p2 = d2 ? formatInstructionFooter(SELECT_INSTRUCTIONS, n4) : n4 ? [styleText2("cyan", S_BAR_END)] : [], b2 = p2.join(`
+`), f2 = p2.length + 1;
+          return `${u4}${r3}${limitOptions({
+            output: t3.output,
+            cursor: this.cursor,
+            options: this.options,
+            maxItems: t3.maxItems,
+            columnPadding: r3.length,
+            rowPadding: a3 + f2,
+            style: (g2, x2) => o2(g2, g2.disabled ? "disabled" : x2 ? "active" : "inactive")
+          }).join(`
+${r3}`)}
+${b2}
+`;
+        }
+      }
+    }
+  }).prompt();
+};
+var i = `${styleText2("gray", S_BAR)}  `;
+var text = (e2) => new n2({
+  validate: e2.validate,
+  placeholder: e2.placeholder,
+  defaultValue: e2.defaultValue,
+  initialValue: e2.initialValue,
+  output: e2.output,
+  signal: e2.signal,
+  input: e2.input,
+  render() {
+    const i3 = e2?.withGuide ?? settings.withGuide, s2 = `${`${i3 ? `${styleText2("gray", S_BAR)}
+` : ""}${symbol(this.state)}  `}${e2.message}
+`, c3 = e2.placeholder && e2.placeholder.length > 0 ? (
+      // biome-ignore lint/style/noNonNullAssertion: guarded by placeholder.length > 0
+      styleText2("inverse", e2.placeholder[0]) + styleText2("dim", e2.placeholder.slice(1))
+    ) : styleText2(["inverse", "hidden"], "_"), o2 = this.userInput ? this.userInputWithCursor : c3, l3 = this.value ?? "";
+    switch (this.state) {
+      case "error": {
+        const n4 = this.error ? `  ${styleText2("yellow", this.error)}` : "", r3 = i3 ? `${styleText2("yellow", S_BAR)}  ` : "", d2 = i3 ? styleText2("yellow", S_BAR_END) : "";
+        return `${s2.trim()}
+${r3}${o2}
+${d2}${n4}
+`;
+      }
+      case "submit": {
+        const n4 = l3 ? `  ${styleText2("dim", l3)}` : "", r3 = i3 ? styleText2("gray", S_BAR) : "";
+        return `${s2}${r3}${n4}`;
+      }
+      case "cancel": {
+        const n4 = l3 ? `  ${styleText2(["strikethrough", "dim"], l3)}` : "", r3 = i3 ? styleText2("gray", S_BAR) : "";
+        return `${s2}${r3}${n4}${l3.trim() ? `
+${r3}` : ""}`;
+      }
+      default: {
+        const n4 = i3 ? `${styleText2("cyan", S_BAR)}  ` : "", r3 = i3 ? styleText2("cyan", S_BAR_END) : "";
+        return `${s2}${n4}${o2}
+${r3}
+`;
+      }
+    }
+  }
+}).prompt();
+
+// node_modules/citty/dist/_chunks/libs/scule.mjs
+var NUMBER_CHAR_RE = /\d/;
+var STR_SPLITTERS = [
+  "-",
+  "_",
+  "/",
+  "."
+];
+function isUppercase(char = "") {
+  if (NUMBER_CHAR_RE.test(char)) return;
+  return char !== char.toLowerCase();
+}
+function splitByCase(str, separators) {
+  const splitters = separators ?? STR_SPLITTERS;
+  const parts = [];
+  if (!str || typeof str !== "string") return parts;
+  let buff = "";
+  let previousUpper;
+  let previousSplitter;
+  for (const char of str) {
+    const isSplitter = splitters.includes(char);
+    if (isSplitter === true) {
+      parts.push(buff);
+      buff = "";
+      previousUpper = void 0;
+      continue;
+    }
+    const isUpper = isUppercase(char);
+    if (previousSplitter === false) {
+      if (previousUpper === false && isUpper === true) {
+        parts.push(buff);
+        buff = char;
+        previousUpper = isUpper;
+        continue;
+      }
+      if (previousUpper === true && isUpper === false && buff.length > 1) {
+        const lastChar = buff.at(-1);
+        parts.push(buff.slice(0, Math.max(0, buff.length - 1)));
+        buff = lastChar + char;
+        previousUpper = isUpper;
+        continue;
+      }
+    }
+    buff += char;
+    previousUpper = isUpper;
+    previousSplitter = isSplitter;
+  }
+  parts.push(buff);
+  return parts;
+}
+function upperFirst(str) {
+  return str ? str[0].toUpperCase() + str.slice(1) : "";
+}
+function lowerFirst(str) {
+  return str ? str[0].toLowerCase() + str.slice(1) : "";
+}
+function pascalCase(str, opts) {
+  return str ? (Array.isArray(str) ? str : splitByCase(str)).map((p2) => upperFirst(opts?.normalize ? p2.toLowerCase() : p2)).join("") : "";
+}
+function camelCase(str, opts) {
+  return lowerFirst(pascalCase(str || "", opts));
+}
+function kebabCase(str, joiner) {
+  return str ? (Array.isArray(str) ? str : splitByCase(str)).map((p2) => p2.toLowerCase()).join(joiner ?? "-") : "";
+}
+function snakeCase(str) {
+  return kebabCase(str || "", "_");
+}
+
+// node_modules/citty/dist/index.mjs
+import { parseArgs as parseArgs$1 } from "node:util";
+function toArray(val) {
+  if (Array.isArray(val)) return val;
+  return val === void 0 ? [] : [val];
+}
+function formatLineColumns(lines, linePrefix = "") {
+  const maxLength = [];
+  for (const line of lines) for (const [i3, element] of line.entries()) maxLength[i3] = Math.max(maxLength[i3] || 0, element.length);
+  return lines.map((l3) => l3.map((c3, i3) => linePrefix + c3[i3 === 0 ? "padStart" : "padEnd"](maxLength[i3])).join("  ")).join("\n");
+}
+function resolveValue(input) {
+  return typeof input === "function" ? input() : input;
+}
+var CLIError = class extends Error {
+  code;
+  constructor(message, code) {
+    super(message);
+    this.name = "CLIError";
+    this.code = code;
+  }
+};
+function parseRawArgs(args = [], opts = {}) {
+  const booleans = new Set(opts.boolean || []);
+  const strings = new Set(opts.string || []);
+  const aliasMap = opts.alias || {};
+  const defaults = opts.default || {};
+  const aliasToMain = /* @__PURE__ */ new Map();
+  const mainToAliases = /* @__PURE__ */ new Map();
+  for (const [key, value] of Object.entries(aliasMap)) {
+    const targets = value;
+    for (const target of targets) {
+      aliasToMain.set(key, target);
+      if (!mainToAliases.has(target)) mainToAliases.set(target, []);
+      mainToAliases.get(target).push(key);
+      aliasToMain.set(target, key);
+      if (!mainToAliases.has(key)) mainToAliases.set(key, []);
+      mainToAliases.get(key).push(target);
+    }
+  }
+  const options = {};
+  function getType(name) {
+    if (booleans.has(name)) return "boolean";
+    const aliases = mainToAliases.get(name) || [];
+    for (const alias of aliases) if (booleans.has(alias)) return "boolean";
+    return "string";
+  }
+  function isStringType(name) {
+    if (strings.has(name)) return true;
+    const aliases = mainToAliases.get(name) || [];
+    for (const alias of aliases) if (strings.has(alias)) return true;
+    return false;
+  }
+  const allOptions = /* @__PURE__ */ new Set([
+    ...booleans,
+    ...strings,
+    ...Object.keys(aliasMap),
+    ...Object.values(aliasMap).flat(),
+    ...Object.keys(defaults)
+  ]);
+  for (const name of allOptions) if (!options[name]) options[name] = {
+    type: getType(name),
+    default: defaults[name]
+  };
+  for (const [alias, main2] of aliasToMain.entries()) if (alias.length === 1 && options[main2] && !options[main2].short) options[main2].short = alias;
+  const processedArgs = [];
+  const negatedFlags = {};
+  for (let i3 = 0; i3 < args.length; i3++) {
+    const arg = args[i3];
+    if (arg === "--") {
+      processedArgs.push(...args.slice(i3));
+      break;
+    }
+    if (arg.startsWith("--no-")) {
+      const flagName = arg.slice(5);
+      negatedFlags[flagName] = true;
+      continue;
+    }
+    processedArgs.push(arg);
+  }
+  let parsed;
+  try {
+    parsed = parseArgs$1({
+      args: processedArgs,
+      options: Object.keys(options).length > 0 ? options : void 0,
+      allowPositionals: true,
+      strict: false
+    });
+  } catch {
+    parsed = {
+      values: {},
+      positionals: processedArgs
+    };
+  }
+  const out = { _: [] };
+  out._ = parsed.positionals;
+  for (const [key, value] of Object.entries(parsed.values)) {
+    let coerced = value;
+    if (getType(key) === "boolean" && typeof value === "string") coerced = value !== "false";
+    else if (isStringType(key) && typeof value === "boolean") coerced = "";
+    out[key] = coerced;
+  }
+  for (const [name] of Object.entries(negatedFlags)) {
+    out[name] = false;
+    const mainName = aliasToMain.get(name);
+    if (mainName) out[mainName] = false;
+    const aliases = mainToAliases.get(name);
+    if (aliases) for (const alias of aliases) out[alias] = false;
+  }
+  for (const [alias, main2] of aliasToMain.entries()) {
+    if (out[alias] !== void 0 && out[main2] === void 0) out[main2] = out[alias];
+    if (out[main2] !== void 0 && out[alias] === void 0) out[alias] = out[main2];
+    if (out[alias] !== out[main2] && defaults[main2] === out[main2]) out[main2] = out[alias];
+  }
+  return out;
+}
+var noColor = /* @__PURE__ */ (() => {
+  const env = globalThis.process?.env ?? {};
+  return env.NO_COLOR === "1" || env.TERM === "dumb" || env.TEST || env.CI;
+})();
+var _c = (c3, r3 = 39) => (t3) => noColor ? t3 : `\x1B[${c3}m${t3}\x1B[${r3}m`;
+var bold = /* @__PURE__ */ _c(1, 22);
+var cyan = /* @__PURE__ */ _c(36);
+var gray = /* @__PURE__ */ _c(90);
+var underline = /* @__PURE__ */ _c(4, 24);
+function parseArgs(rawArgs, argsDef) {
+  const parseOptions = {
+    boolean: [],
+    string: [],
+    alias: {},
+    default: {}
+  };
+  const args = resolveArgs(argsDef);
+  for (const arg of args) {
+    if (arg.type === "positional") continue;
+    if (arg.type === "string" || arg.type === "enum") parseOptions.string.push(arg.name);
+    else if (arg.type === "boolean") parseOptions.boolean.push(arg.name);
+    if (arg.default !== void 0) parseOptions.default[arg.name] = arg.default;
+    if (arg.alias) parseOptions.alias[arg.name] = arg.alias;
+    const camelName = camelCase(arg.name);
+    const kebabName = kebabCase(arg.name);
+    if (camelName !== arg.name || kebabName !== arg.name) {
+      const existingAliases = toArray(parseOptions.alias[arg.name] || []);
+      if (camelName !== arg.name && !existingAliases.includes(camelName)) existingAliases.push(camelName);
+      if (kebabName !== arg.name && !existingAliases.includes(kebabName)) existingAliases.push(kebabName);
+      if (existingAliases.length > 0) parseOptions.alias[arg.name] = existingAliases;
+    }
+  }
+  const parsed = parseRawArgs(rawArgs, parseOptions);
+  const [...positionalArguments] = parsed._;
+  const parsedArgsProxy = new Proxy(parsed, { get(target, prop) {
+    return target[prop] ?? target[camelCase(prop)] ?? target[kebabCase(prop)];
+  } });
+  for (const [, arg] of args.entries()) if (arg.type === "positional") {
+    const nextPositionalArgument = positionalArguments.shift();
+    if (nextPositionalArgument !== void 0) parsedArgsProxy[arg.name] = nextPositionalArgument;
+    else if (arg.default === void 0 && arg.required !== false) throw new CLIError(`Missing required positional argument: ${arg.name.toUpperCase()}`, "EARG");
+    else parsedArgsProxy[arg.name] = arg.default;
+  } else if (arg.type === "enum") {
+    const argument = parsedArgsProxy[arg.name];
+    const options = arg.options || [];
+    if (argument !== void 0 && options.length > 0 && !options.includes(argument)) throw new CLIError(`Invalid value for argument: ${cyan(`--${arg.name}`)} (${cyan(argument)}). Expected one of: ${options.map((o2) => cyan(o2)).join(", ")}.`, "EARG");
+  } else if (arg.required && parsedArgsProxy[arg.name] === void 0) throw new CLIError(`Missing required argument: --${arg.name}`, "EARG");
+  return parsedArgsProxy;
+}
+function resolveArgs(argsDef) {
+  const args = [];
+  for (const [name, argDef] of Object.entries(argsDef || {})) args.push({
+    ...argDef,
+    name,
+    alias: toArray(argDef.alias)
+  });
+  return args;
+}
+async function resolvePlugins(plugins) {
+  return Promise.all(plugins.map((p2) => resolveValue(p2)));
+}
+function defineCommand(def) {
+  return def;
+}
+async function runCommand(cmd, opts) {
+  const cmdArgs = await resolveValue(cmd.args || {});
+  const parsedArgs = parseArgs(opts.rawArgs, cmdArgs);
+  const context = {
+    rawArgs: opts.rawArgs,
+    args: parsedArgs,
+    data: opts.data,
+    cmd
+  };
+  const plugins = await resolvePlugins(cmd.plugins ?? []);
+  let result;
+  let runError;
+  try {
+    for (const plugin of plugins) await plugin.setup?.(context);
+    if (typeof cmd.setup === "function") await cmd.setup(context);
+    const subCommands = await resolveValue(cmd.subCommands);
+    if (subCommands && Object.keys(subCommands).length > 0) {
+      const subCommandArgIndex = findSubCommandIndex(opts.rawArgs, cmdArgs);
+      const explicitName = opts.rawArgs[subCommandArgIndex];
+      if (explicitName) {
+        const subCommand = await _findSubCommand(subCommands, explicitName);
+        if (!subCommand) throw new CLIError(`Unknown command ${cyan(explicitName)}`, "E_UNKNOWN_COMMAND");
+        await runCommand(subCommand, { rawArgs: opts.rawArgs.slice(subCommandArgIndex + 1) });
+      } else {
+        const defaultSubCommand = await resolveValue(cmd.default);
+        if (defaultSubCommand) {
+          if (cmd.run) throw new CLIError(`Cannot specify both 'run' and 'default' on the same command.`, "E_DEFAULT_CONFLICT");
+          const subCommand = await _findSubCommand(subCommands, defaultSubCommand);
+          if (!subCommand) throw new CLIError(`Default sub command ${cyan(defaultSubCommand)} not found in subCommands.`, "E_UNKNOWN_COMMAND");
+          await runCommand(subCommand, { rawArgs: opts.rawArgs });
+        } else if (!cmd.run) throw new CLIError(`No command specified.`, "E_NO_COMMAND");
+      }
+    }
+    if (typeof cmd.run === "function") result = await cmd.run(context);
+  } catch (error) {
+    runError = error;
+  }
+  const cleanupErrors = [];
+  if (typeof cmd.cleanup === "function") try {
+    await cmd.cleanup(context);
+  } catch (error) {
+    cleanupErrors.push(error);
+  }
+  for (const plugin of [...plugins].reverse()) try {
+    await plugin.cleanup?.(context);
+  } catch (error) {
+    cleanupErrors.push(error);
+  }
+  if (runError) throw runError;
+  if (cleanupErrors.length === 1) throw cleanupErrors[0];
+  if (cleanupErrors.length > 1) throw new Error("Multiple cleanup errors", { cause: cleanupErrors });
+  return { result };
+}
+async function resolveSubCommand(cmd, rawArgs, parent) {
+  const subCommands = await resolveValue(cmd.subCommands);
+  if (subCommands && Object.keys(subCommands).length > 0) {
+    const subCommandArgIndex = findSubCommandIndex(rawArgs, await resolveValue(cmd.args || {}));
+    const subCommandName = rawArgs[subCommandArgIndex];
+    const subCommand = await _findSubCommand(subCommands, subCommandName);
+    if (subCommand) return resolveSubCommand(subCommand, rawArgs.slice(subCommandArgIndex + 1), cmd);
+  }
+  return [cmd, parent];
+}
+async function _findSubCommand(subCommands, name) {
+  if (name in subCommands) return resolveValue(subCommands[name]);
+  for (const sub of Object.values(subCommands)) {
+    const resolved = await resolveValue(sub);
+    const meta = await resolveValue(resolved?.meta);
+    if (meta?.alias) {
+      if (toArray(meta.alias).includes(name)) return resolved;
+    }
+  }
+}
+function findSubCommandIndex(rawArgs, argsDef) {
+  for (let i3 = 0; i3 < rawArgs.length; i3++) {
+    const arg = rawArgs[i3];
+    if (arg === "--") return -1;
+    if (arg.startsWith("-")) {
+      if (!arg.includes("=") && _isValueFlag(arg, argsDef)) i3++;
+      continue;
+    }
+    return i3;
+  }
+  return -1;
+}
+function _isValueFlag(flag, argsDef) {
+  const name = flag.replace(/^-{1,2}/, "");
+  const normalized = camelCase(name);
+  for (const [key, def] of Object.entries(argsDef)) {
+    if (def.type !== "string" && def.type !== "enum") continue;
+    if (normalized === camelCase(key)) return true;
+    if ((Array.isArray(def.alias) ? def.alias : def.alias ? [def.alias] : []).includes(name)) return true;
+  }
+  return false;
+}
+async function showUsage(cmd, parent) {
+  try {
+    console.log(await renderUsage(cmd, parent) + "\n");
+  } catch (error) {
+    console.error(error);
+  }
+}
+var negativePrefixRe = /^no[-A-Z]/;
+async function renderUsage(cmd, parent) {
+  const cmdMeta = await resolveValue(cmd.meta || {});
+  const cmdArgs = resolveArgs(await resolveValue(cmd.args || {}));
+  const parentMeta = await resolveValue(parent?.meta || {});
+  const commandName = `${parentMeta.name ? `${parentMeta.name} ` : ""}` + (cmdMeta.name || process.argv[1]);
+  const argLines = [];
+  const posLines = [];
+  const commandsLines = [];
+  const usageLine = [];
+  for (const arg of cmdArgs) if (arg.type === "positional") {
+    const name = arg.name.toUpperCase();
+    const isRequired = arg.required !== false && arg.default === void 0;
+    posLines.push([cyan(name + renderValueHint(arg)), renderDescription(arg, isRequired)]);
+    usageLine.push(isRequired ? `<${name}>` : `[${name}]`);
+  } else {
+    const isRequired = arg.required === true && arg.default === void 0;
+    const argStr = [...(arg.alias || []).map((a3) => `-${a3}`), `--${arg.name}`].join(", ") + renderValueHint(arg);
+    argLines.push([cyan(argStr), renderDescription(arg, isRequired)]);
+    if (arg.type === "boolean" && (arg.default === true || arg.negativeDescription) && !negativePrefixRe.test(arg.name)) {
+      const negativeArgStr = [...(arg.alias || []).map((a3) => `--no-${a3}`), `--no-${arg.name}`].join(", ");
+      argLines.push([cyan(negativeArgStr), [arg.negativeDescription, isRequired ? gray("(Required)") : ""].filter(Boolean).join(" ")]);
+    }
+    if (isRequired) usageLine.push(`--${arg.name}` + renderValueHint(arg));
+  }
+  if (cmd.subCommands) {
+    const commandNames = [];
+    const subCommands = await resolveValue(cmd.subCommands);
+    for (const [name, sub] of Object.entries(subCommands)) {
+      const meta = await resolveValue((await resolveValue(sub))?.meta);
+      if (meta?.hidden) continue;
+      const aliases = toArray(meta?.alias);
+      const label = [name, ...aliases].join(", ");
+      commandsLines.push([cyan(label), meta?.description || ""]);
+      commandNames.push(name, ...aliases);
+    }
+    usageLine.push(commandNames.join("|"));
+  }
+  const usageLines = [];
+  const version = cmdMeta.version || parentMeta.version;
+  usageLines.push(gray(`${cmdMeta.description} (${commandName + (version ? ` v${version}` : "")})`), "");
+  const hasOptions = argLines.length > 0 || posLines.length > 0;
+  usageLines.push(`${underline(bold("USAGE"))} ${cyan(`${commandName}${hasOptions ? " [OPTIONS]" : ""} ${usageLine.join(" ")}`)}`, "");
+  if (posLines.length > 0) {
+    usageLines.push(underline(bold("ARGUMENTS")), "");
+    usageLines.push(formatLineColumns(posLines, "  "));
+    usageLines.push("");
+  }
+  if (argLines.length > 0) {
+    usageLines.push(underline(bold("OPTIONS")), "");
+    usageLines.push(formatLineColumns(argLines, "  "));
+    usageLines.push("");
+  }
+  if (commandsLines.length > 0) {
+    usageLines.push(underline(bold("COMMANDS")), "");
+    usageLines.push(formatLineColumns(commandsLines, "  "));
+    usageLines.push("", `Use ${cyan(`${commandName} <command> --help`)} for more information about a command.`);
+  }
+  return usageLines.filter((l3) => typeof l3 === "string").join("\n");
+}
+function renderValueHint(arg) {
+  const valueHint = arg.valueHint ? `=<${arg.valueHint}>` : "";
+  const fallbackValueHint = valueHint || `=<${snakeCase(arg.name)}>`;
+  if (!arg.type || arg.type === "positional" || arg.type === "boolean") return valueHint;
+  if (arg.type === "enum" && arg.options?.length) return `=<${arg.options.join("|")}>`;
+  return fallbackValueHint;
+}
+function renderDescription(arg, required) {
+  const requiredHint = required ? gray("(Required)") : "";
+  const defaultHint = arg.default === void 0 ? "" : gray(`(Default: ${arg.default})`);
+  return [
+    arg.description,
+    requiredHint,
+    defaultHint
+  ].filter(Boolean).join(" ");
+}
+async function runMain(cmd, opts = {}) {
+  const rawArgs = opts.rawArgs || process.argv.slice(2);
+  const showUsage$1 = opts.showUsage || showUsage;
+  try {
+    const builtinFlags = await _resolveBuiltinFlags(cmd);
+    if (builtinFlags.help.length > 0 && rawArgs.some((arg) => builtinFlags.help.includes(arg))) {
+      await showUsage$1(...await resolveSubCommand(cmd, rawArgs));
+      process.exit(0);
+    } else if (rawArgs.length === 1 && builtinFlags.version.includes(rawArgs[0])) {
+      const meta = typeof cmd.meta === "function" ? await cmd.meta() : await cmd.meta;
+      if (!meta?.version) throw new CLIError("No version specified", "E_NO_VERSION");
+      console.log(meta.version);
+    } else await runCommand(cmd, { rawArgs });
+  } catch (error) {
+    if (error instanceof CLIError) {
+      await showUsage$1(...await resolveSubCommand(cmd, rawArgs));
+      console.error(error.message);
+    } else console.error(error, "\n");
+    process.exit(1);
+  }
+}
+async function _resolveBuiltinFlags(cmd) {
+  const argsDef = await resolveValue(cmd.args || {});
+  const userNames = /* @__PURE__ */ new Set();
+  const userAliases = /* @__PURE__ */ new Set();
+  for (const [name, def] of Object.entries(argsDef)) {
+    userNames.add(name);
+    for (const alias of toArray(def.alias)) userAliases.add(alias);
+  }
+  return {
+    help: _getBuiltinFlags("help", "h", userNames, userAliases),
+    version: _getBuiltinFlags("version", "v", userNames, userAliases)
+  };
+}
+function _getBuiltinFlags(long, short, userNames, userAliases) {
+  if (userNames.has(long) || userAliases.has(long)) return [];
+  if (userNames.has(short) || userAliases.has(short)) return [`--${long}`];
+  return [`--${long}`, `-${short}`];
+}
+
+// package.json
+var package_default = {
+  name: "zapdev",
+  version: "0.6.0",
+  description: "Fast, performant and lightweight git chores and dev tools using your terminal and your own local LLM.",
+  type: "module",
+  bin: {
+    zapdev: "./dist/index.js"
+  },
+  files: [
+    "dist"
+  ],
+  engines: {
+    node: ">=20"
+  },
+  keywords: [
+    "git",
+    "cli",
+    "commit",
+    "conventional-commits",
+    "ollama",
+    "llm",
+    "ai"
+  ],
+  author: "Matthieu Vagnon <hi@mvagnon.dev>",
+  license: "MIT",
+  repository: {
+    type: "git",
+    url: "git+https://github.com/mvagnon/zapdev.git"
+  },
+  homepage: "https://github.com/mvagnon/zapdev#readme",
+  bugs: {
+    url: "https://github.com/mvagnon/zapdev/issues"
+  },
+  publishConfig: {
+    access: "public"
+  },
+  scripts: {
+    zapdev: "npm run build && node dist/index.js",
+    build: "esbuild src/cli.ts --bundle --platform=node --format=esm --target=node20 --loader:.md=text --outfile=dist/cli.js && esbuild src/index.ts --platform=node --format=esm --target=node20 --outfile=dist/index.js",
+    lint: "eslint .",
+    typecheck: "tsc --noEmit",
+    test: "vitest run",
+    prepack: "npm run build"
+  },
+  devDependencies: {
+    "@clack/prompts": "^1.6.0",
+    "@eslint/js": "^10.0.1",
+    "@eslint/json": "^2.0.0",
+    "@eslint/markdown": "^8.0.2",
+    "@types/node": "^26.1.1",
+    citty: "^0.2.2",
+    esbuild: "^0.28.1",
+    eslint: "^10.6.0",
+    jiti: "^2.7.0",
+    tinyexec: "^1.2.4",
+    typescript: "^6.0.3",
+    "typescript-eslint": "^8.62.1",
+    vitest: "^4.1.9"
+  }
+};
+
+// src/lib/branches.ts
+function parseDefaultBranch(originHead) {
+  const trimmed = originHead.trim();
+  if (!trimmed) return null;
+  return trimmed.replace(/^origin\//, "");
+}
+function parseBranches(raw) {
+  return raw.split("\n").map((branch) => branch.trim()).filter(Boolean);
+}
+function deletableBranches(all, protectedBranches) {
+  const kept = new Set(protectedBranches.filter(Boolean));
+  return all.filter((branch) => !kept.has(branch));
+}
+
+// src/lib/errors.ts
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+// src/lib/git.ts
+import { readdir } from "node:fs/promises";
+import { join } from "node:path";
+
+// node_modules/tinyexec/dist/main.mjs
+import { spawn as e, spawnSync as t2 } from "node:child_process";
+import { cwd as n3 } from "node:process";
+import { basename as r2, delimiter as i2, dirname as a2, normalize as o, resolve as s } from "node:path";
+import { pipeline as c2 } from "node:stream/promises";
+import { PassThrough as l2 } from "node:stream";
+import u3 from "node:readline";
+import { closeSync as d, openSync as f, readSync as p, statSync as m2 } from "node:fs";
+var h2 = /^path$/i;
+var g = {
+  key: "PATH",
+  value: ""
+};
+function _(e2) {
+  for (const t3 in e2) {
+    if (!Object.prototype.hasOwnProperty.call(e2, t3) || !h2.test(t3)) continue;
+    const n4 = e2[t3];
+    if (!n4) return g;
+    return {
+      key: t3,
+      value: n4
+    };
+  }
+  return g;
+}
+function v(e2, t3) {
+  const n4 = t3.value.split(i2);
+  const r3 = [];
+  let o2 = e2;
+  let c3;
+  do {
+    r3.push(s(o2, "node_modules", ".bin"));
+    c3 = o2;
+    o2 = a2(o2);
+  } while (o2 !== c3);
+  r3.push(a2(process.execPath));
+  const l3 = r3.concat(n4).join(i2);
+  return {
+    key: t3.key,
+    value: l3
+  };
+}
+function y(e2, t3, n4 = true) {
+  const r3 = {
+    ...process.env,
+    ...t3
+  };
+  if (!n4) return r3;
+  const i3 = v(e2, _(r3));
+  r3[i3.key] = i3.value;
+  return r3;
+}
+var b = (e2) => {
+  let t3 = e2.length;
+  const n4 = new l2();
+  const r3 = () => {
+    if (--t3 === 0) n4.end();
+  };
+  for (const t4 of e2) c2(t4, n4, { end: false }).then(r3).catch(r3);
+  return n4;
+};
+var x = /([()\][%!^"`<>&|;, *?])/g;
+var S = /^#!\s*(.+)/;
+var C = /\.(?:com|exe)$/i;
+var w = /node_modules[\\/]\.bin[\\/][^\\/]+\.cmd$/i;
+var T = process.platform === "win32";
+var E = [
+  ".EXE",
+  ".CMD",
+  ".BAT",
+  ".COM"
+];
+function D(e2, t3 = [], n4 = {}) {
+  if (n4.shell === true || !T) return {
+    command: e2,
+    args: t3,
+    options: n4
+  };
+  let i3 = O(e2, n4);
+  let a3 = null;
+  if (i3 !== null) {
+    const e3 = 150;
+    const t4 = Buffer.alloc(e3);
+    let n5 = null;
+    try {
+      n5 = f(i3, "r");
+      p(n5, t4, 0, e3, 0);
+    } catch {
+    } finally {
+      if (n5 !== null) d(n5);
+    }
+    const o2 = t4.toString().match(S);
+    if (o2 !== null) {
+      const e4 = o2[1].trim();
+      const t5 = e4.indexOf(" ");
+      const n6 = t5 !== -1 ? e4.slice(0, t5) : e4;
+      const i4 = t5 !== -1 ? e4.slice(t5 + 1) : "";
+      const s2 = r2(n6);
+      a3 = s2 === "env" ? i4 || null : s2;
+    }
+  }
+  if (a3 !== null && i3 !== null) {
+    t3 = [i3, ...t3];
+    e2 = a3;
+    i3 = O(e2, n4);
+  }
+  if (i3 === null || !C.test(i3)) {
+    const r3 = i3 !== null && w.test(i3);
+    e2 = o(e2);
+    e2 = e2.replace(x, "^$1");
+    t3 = t3.map((e3) => {
+      e3 = e3.replace(/(?=(\\+?)?)\1"/g, '$1$1\\"');
+      e3 = e3.replace(/(?=(\\+?)?)\1$/, "$1$1");
+      e3 = `"${e3}"`;
+      e3 = e3.replace(x, "^$1");
+      if (r3) e3 = e3.replace(x, "^$1");
+      return e3;
+    });
+    t3 = [
+      "/d",
+      "/s",
+      "/c",
+      `"${[e2, ...t3].join(" ")}"`
+    ];
+    e2 = n4.env?.comspec ?? "cmd.exe";
+    n4 = {
+      ...n4,
+      windowsVerbatimArguments: true
+    };
+  }
+  return {
+    command: e2,
+    args: t3,
+    options: n4
+  };
+}
+function O(e2, t3) {
+  const r3 = (t3.cwd ?? n3()).toString();
+  const a3 = t3.env ?? process.env;
+  const o2 = _(a3).value;
+  const c3 = e2.includes("/") || e2.includes("\\") ? [""] : [r3, ...o2.split(i2)];
+  const l3 = a3.PATHEXT ? a3.PATHEXT.split(i2) : E;
+  if (e2.includes(".") && l3[0] !== "") l3.unshift("");
+  for (const t4 of c3) {
+    const n4 = s(r3, t4.startsWith('"') && t4.endsWith('"') && t4.length > 1 ? t4.slice(1, -1) : t4, e2);
+    for (const e3 of l3) {
+      const t5 = n4 + e3;
+      try {
+        if (m2(t5).isFile()) return t5;
+      } catch {
+      }
+    }
+  }
+  return null;
+}
+var k = class extends Error {
+  result;
+  output;
+  get exitCode() {
+    if (this.result.exitCode !== null) return this.result.exitCode;
+  }
+  constructor(e2, t3) {
+    super(`Process exited with non-zero status (${e2.exitCode})`);
+    this.result = e2;
+    this.output = t3;
+  }
+};
+var j = {
+  timeout: void 0,
+  persist: false
+};
+var N = { windowsHide: true };
+function P(e2) {
+  const t3 = new AbortController();
+  for (const n4 of e2) {
+    if (n4.aborted) {
+      t3.abort();
+      return n4;
+    }
+    const e3 = () => {
+      t3.abort(n4.reason);
+    };
+    n4.addEventListener("abort", e3, { signal: t3.signal });
+  }
+  return t3.signal;
+}
+async function F(e2) {
+  let t3 = "";
+  try {
+    for await (const n4 of e2) t3 += n4.toString();
+  } catch {
+  }
+  return t3;
+}
+var I2 = class {
+  _process;
+  _aborted = false;
+  _options;
+  _command;
+  _args;
+  _resolveClose;
+  _processClosed;
+  _thrownError;
+  get process() {
+    return this._process;
+  }
+  get pid() {
+    return this._process?.pid;
+  }
+  get exitCode() {
+    if (this._process && this._process.exitCode !== null) return this._process.exitCode;
+  }
+  constructor(e2, t3, n4) {
+    this._options = {
+      ...j,
+      ...n4
+    };
+    this._command = e2;
+    this._args = t3 ?? [];
+    this._processClosed = new Promise((e3) => {
+      this._resolveClose = e3;
+    });
+  }
+  kill(e2) {
+    return this._process?.kill(e2) === true;
+  }
+  get aborted() {
+    return this._aborted;
+  }
+  get killed() {
+    return this._process?.killed === true;
+  }
+  pipe(e2, t3, n4) {
+    return z(e2, t3, {
+      ...n4,
+      stdin: this
+    });
+  }
+  async *[Symbol.asyncIterator]() {
+    const e2 = this._process;
+    if (!e2) return;
+    const t3 = [];
+    if (this._streamErr) t3.push(this._streamErr);
+    if (this._streamOut) t3.push(this._streamOut);
+    const n4 = b(t3);
+    const r3 = u3.createInterface({ input: n4 });
+    for await (const e3 of r3) yield e3.toString();
+    await this._processClosed;
+    e2.removeAllListeners();
+    if (this._thrownError) throw this._thrownError;
+    if (this._options?.throwOnError && this.exitCode !== 0 && this.exitCode !== void 0) throw new k(this);
+  }
+  async _waitForOutput() {
+    const e2 = this._process;
+    if (!e2) throw new Error("No process was started");
+    const [t3, n4] = await Promise.all([this._streamOut ? F(this._streamOut) : "", this._streamErr ? F(this._streamErr) : ""]);
+    await this._processClosed;
+    const { stdin: r3 } = this._options;
+    if (r3 && typeof r3 !== "string") await r3;
+    e2.removeAllListeners();
+    if (this._thrownError) throw this._thrownError;
+    const i3 = {
+      stderr: n4,
+      stdout: t3,
+      exitCode: this.exitCode
+    };
+    if (this._options.throwOnError && this.exitCode !== 0 && this.exitCode !== void 0) throw new k(this, i3);
+    return i3;
+  }
+  then(e2, t3) {
+    return this._waitForOutput().then(e2, t3);
+  }
+  _streamOut;
+  _streamErr;
+  spawn() {
+    const t3 = n3();
+    const r3 = this._options;
+    const i3 = {
+      ...N,
+      ...r3.nodeOptions
+    };
+    const a3 = [];
+    this._resetState();
+    if (r3.timeout !== void 0) a3.push(AbortSignal.timeout(r3.timeout));
+    if (r3.signal !== void 0) a3.push(r3.signal);
+    if (r3.persist === true) i3.detached = true;
+    if (a3.length > 0) i3.signal = P(a3);
+    i3.env = y(t3, i3.env, r3.nodePath);
+    const o2 = D(this._command, this._args, i3);
+    const s2 = e(o2.command, o2.args, o2.options);
+    if (s2.stderr) this._streamErr = s2.stderr;
+    if (s2.stdout) this._streamOut = s2.stdout;
+    this._process = s2;
+    s2.once("error", this._onError);
+    s2.once("close", this._onClose);
+    if (s2.stdin) {
+      const { stdin: e2 } = r3;
+      if (typeof e2 === "string") s2.stdin.end(e2);
+      else e2?.process?.stdout?.pipe(s2.stdin);
+    }
+  }
+  _resetState() {
+    this._aborted = false;
+    this._processClosed = new Promise((e2) => {
+      this._resolveClose = e2;
+    });
+    this._thrownError = void 0;
+  }
+  _onError = (e2) => {
+    if (e2.name === "AbortError" && (!(e2.cause instanceof Error) || e2.cause.name !== "TimeoutError")) {
+      this._aborted = true;
+      return;
+    }
+    this._thrownError = e2;
+  };
+  _onClose = () => {
+    if (this._resolveClose) this._resolveClose();
+  };
+};
+var R2 = (e2, t3, n4) => {
+  const r3 = new I2(e2, t3, n4);
+  r3.spawn();
+  return r3;
+};
+var z = R2;
+
+// src/lib/git.ts
+var UPSTREAM_REF = "@{upstream}";
+var BRANCH_FORMAT = "%(refname:short)";
+async function git(args, cwd) {
+  const result = await R2("git", args, { nodeOptions: { cwd } });
+  if (result.exitCode !== 0) {
+    throw new Error(result.stderr.trim() || `git ${args.join(" ")} failed`);
+  }
+  return result.stdout;
+}
+async function tryGit(args, cwd) {
+  const result = await R2("git", args, { nodeOptions: { cwd } });
+  return result.exitCode === 0 ? result.stdout : null;
+}
+async function stageAll() {
+  await git(["add", "-A"]);
+}
+async function getStagedDiff() {
+  return git(["diff", "--cached"]);
+}
+async function commit(message) {
+  await git(["commit", "-m", message]);
+}
+async function currentBranch() {
+  return (await git(["symbolic-ref", "--short", "HEAD"])).trim();
+}
+async function hasUpstream() {
+  const result = await tryGit(["rev-parse", "--abbrev-ref", "--symbolic-full-name", UPSTREAM_REF]);
+  return result !== null;
+}
+async function push() {
+  await git(["push"]);
+}
+async function pushSetUpstream(branch) {
+  await git(["push", "-u", "origin", branch]);
+}
+async function findGitRepos(start) {
+  const repos = [];
+  await collectRepos(start, repos);
+  return repos.sort();
+}
+async function collectRepos(dir, repos) {
+  const entries = await readdir(dir, { withFileTypes: true }).catch(() => null);
+  if (!entries) return;
+  if (entries.some((entry) => entry.name === ".git")) {
+    repos.push(dir);
+    return;
+  }
+  const subdirs = entries.filter(
+    (entry) => entry.isDirectory() && entry.name !== "node_modules"
+  );
+  await Promise.all(subdirs.map((entry) => collectRepos(join(dir, entry.name), repos)));
+}
+async function fetchPrune(repo) {
+  await git(["fetch", "--prune"], repo);
+}
+async function defaultBranch(repo) {
+  const output = await tryGit(
+    ["symbolic-ref", "--quiet", "--short", "refs/remotes/origin/HEAD"],
+    repo
+  );
+  return output === null ? null : parseDefaultBranch(output);
+}
+async function currentBranchAt(repo) {
+  const output = await tryGit(["symbolic-ref", "--quiet", "--short", "HEAD"], repo);
+  return output === null ? null : output.trim();
+}
+async function localBranches(repo) {
+  return parseBranches(await git(["branch", `--format=${BRANCH_FORMAT}`], repo));
+}
+async function switchBranch(repo, branch) {
+  await git(["switch", branch], repo);
+}
+async function deleteBranch(repo, branch) {
+  await git(["branch", "-D", branch], repo);
+}
+async function pull(repo) {
+  await git(["pull"], repo);
+}
+
+// src/commands/cleanup.ts
+var cleanupCommand = defineCommand({
+  meta: {
+    name: "cleanup",
+    description: "Prune every git repo under a path, then delete stale local branches."
+  },
+  args: {
+    path: {
+      type: "positional",
+      required: false,
+      default: ".",
+      description: "Directory to scan for git repos (recursively)."
+    },
+    stay: {
+      type: "boolean",
+      alias: "s",
+      description: "Stay on the current branch instead of switching to the default."
+    },
+    pull: {
+      type: "boolean",
+      alias: "p",
+      description: "Pull the checked-out branch after cleanup without asking."
+    },
+    yes: {
+      type: "boolean",
+      alias: "y",
+      description: "Non-interactive: switch to default and delete every other local branch."
+    }
+  },
+  async run({ args }) {
+    const interactive = Boolean(process.stdin.isTTY && process.stdout.isTTY) && !args.yes;
+    const options = { stay: Boolean(args.stay), pull: Boolean(args.pull) };
+    const path = args.path || ".";
+    if (interactive) intro("zapdev cleanup");
+    const repos = await findGitRepos(path);
+    if (repos.length === 0) {
+      log.warn(`No git repository found under ${path}.`);
+      if (interactive) outro("Nothing to do.");
+      return;
+    }
+    for (const repo of repos) {
+      const cancelled = await cleanupRepo(repo, options, interactive);
+      if (cancelled) {
+        cancel("Cancelled.");
+        return;
+      }
+    }
+    if (interactive) outro(`Done (${repos.length} repo${repos.length > 1 ? "s" : ""}).`);
+  }
+});
+async function cleanupRepo(repo, options, interactive) {
+  log.step(`Cleaning ${repo}`);
+  const fetchLoader = interactive ? spinner() : void 0;
+  fetchLoader?.start("Fetching + pruning\u2026");
+  try {
+    await fetchPrune(repo);
+    fetchLoader?.stop("Fetched + pruned");
+  } catch (error) {
+    fetchLoader?.error("Fetch failed");
+    log.warn(`  Fetch failed, continuing: ${errorMessage(error)}`);
+  }
+  const [base, current] = await Promise.all([defaultBranch(repo), currentBranchAt(repo)]);
+  if (!base) {
+    log.warn("  Skipped: no origin/HEAD.");
+    return false;
+  }
+  let endBranch = base;
+  if (current && current !== base) {
+    if (options.stay) {
+      endBranch = current;
+    } else if (interactive) {
+      const choice = await select({
+        message: "After cleanup, be on:",
+        initialValue: base,
+        options: [
+          { value: base, label: `Switch to ${base}` },
+          { value: current, label: `Stay on ${current} (keep it)` }
+        ]
+      });
+      if (isCancel(choice)) return true;
+      endBranch = choice;
+    }
+  }
+  if (current !== endBranch) {
+    try {
+      await switchBranch(repo, endBranch);
+    } catch (error) {
+      log.error(`  Could not switch to ${endBranch}: ${errorMessage(error)}`);
+      return false;
+    }
+  }
+  const candidates = deletableBranches(await localBranches(repo), [base, endBranch]);
+  if (candidates.length === 0) {
+    log.info("  No branch to delete.");
+  } else {
+    let toDelete = candidates;
+    if (interactive) {
+      const selected = await multiselect({
+        message: "Branches to delete",
+        options: candidates.map((branch) => ({ value: branch, label: branch })),
+        required: false
+      });
+      if (isCancel(selected)) return true;
+      toDelete = selected;
+    }
+    let deleted = 0;
+    for (const branch of toDelete) {
+      try {
+        await deleteBranch(repo, branch);
+        deleted += 1;
+      } catch (error) {
+        log.error(`  Could not delete ${branch}: ${errorMessage(error)}`);
+      }
+    }
+    if (deleted > 0) log.success(`  Deleted ${deleted} branch${deleted > 1 ? "es" : ""}.`);
+  }
+  let shouldPull = options.pull;
+  if (!shouldPull && interactive) {
+    const answer = await confirm({ message: `Pull ${endBranch}?`, initialValue: false });
+    if (isCancel(answer)) return true;
+    shouldPull = answer;
+  }
+  if (shouldPull) {
+    const pullLoader = interactive ? spinner() : void 0;
+    pullLoader?.start(`Pulling ${endBranch}\u2026`);
+    try {
+      await pull(repo);
+      pullLoader?.stop(`\u2713 Pulled ${endBranch}`);
+    } catch (error) {
+      pullLoader?.error("Pull failed");
+      log.error(`  Pull failed: ${errorMessage(error)}`);
+    }
+  }
+  return false;
+}
+
+// src/types/commit.ts
+var COMMIT_TYPES = [
+  "feat",
+  "fix",
+  "chore",
+  "docs",
+  "style",
+  "refactor",
+  "perf",
+  "test",
+  "build",
+  "ci",
+  "revert"
+];
+
+// src/lib/commit-message.ts
+function normalizeCommitType(input) {
+  const normalized = input.trim().toLowerCase();
+  return COMMIT_TYPES.includes(normalized) ? normalized : null;
+}
+function applyCommitType(systemPrompt, type) {
+  return `${systemPrompt}
+
+The type MUST be exactly "${type}".`;
+}
+var MAX_DIFF_CHARS = 12e3;
+function truncateDiff(diff, max = MAX_DIFF_CHARS) {
+  return diff.length > max ? diff.slice(0, max) : diff;
+}
+function sanitizeCommitMessage(raw) {
+  const firstLine = raw.split("\n", 1)[0] ?? "";
+  return firstLine.replace(/[`"]/g, "").trim();
+}
+
+// src/lib/config.ts
+var DEFAULT_OLLAMA_URL = "http://localhost:11434";
+var DEFAULT_MODEL = "deepseek-v4-flash:cloud";
+function resolveConfig(env = process.env, overrides = {}) {
+  return {
+    ollamaUrl: normalizeBaseUrl(overrides.ollamaUrl ?? env.OLLAMA_URL ?? DEFAULT_OLLAMA_URL),
+    model: overrides.model ?? env.OLLAMA_MODEL ?? DEFAULT_MODEL
+  };
+}
+function normalizeBaseUrl(raw) {
+  const trimmed = raw.trim().replace(/\/+$/, "");
+  return /^https?:\/\//.test(trimmed) ? trimmed : `http://${trimmed}`;
+}
+
+// src/prompts/commit-message.md
+var commit_message_default = "You are zapdev, a CLI tool that creates commits quickly and reliably.\n\nGenerate ONE commit message in Conventional Commits format.\nA single line: imperative, English, \u226472 chars.\n\nStrictly follow this format:\n\n```text\ntype(scope): description\n```\n\nReply ONLY with the message, no backticks, no quotes, no explanation.\n";
+
+// src/prompts/index.ts
+var COMMIT_SYSTEM_PROMPT = commit_message_default.trim();
+
+// src/lib/ollama.ts
+var REQUEST_TIMEOUT_MS = 25e3;
+var KEEP_ALIVE = "30m";
+async function generateCommitMessage(diff, config, type) {
+  const systemPrompt = type ? applyCommitType(COMMIT_SYSTEM_PROMPT, type) : COMMIT_SYSTEM_PROMPT;
+  const content = await chat(config, [
+    { role: "system", content: systemPrompt },
+    { role: "user", content: truncateDiff(diff) }
+  ]);
+  return sanitizeCommitMessage(content);
+}
+async function chat(config, messages) {
+  const url = `${config.ollamaUrl}/api/chat`;
+  let response;
+  try {
+    response = await fetch(url, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({
+        model: config.model,
+        stream: false,
+        keep_alive: KEEP_ALIVE,
+        options: { temperature: 0.2 },
+        messages
+      }),
+      signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS)
+    });
+  } catch (error) {
+    throw new Error(describeRequestError(error, url), { cause: error });
+  }
+  const body = await response.json().catch(() => null);
+  if (!response.ok) {
+    throw new Error(`Ollama error: ${serverError(body) ?? `HTTP ${response.status}`}`);
+  }
+  const content = messageContent(body);
+  if (content === null) throw new Error("Ollama returned an unexpected response shape.");
+  return content;
+}
+function describeRequestError(error, url) {
+  if (errorName(error) === "TimeoutError") {
+    return `Ollama did not answer within ${REQUEST_TIMEOUT_MS / 1e3}s (${url}).`;
+  }
+  return `Could not reach Ollama at ${url}. Is it running?`;
+}
+function errorName(error) {
+  if (error && typeof error === "object" && "name" in error && typeof error.name === "string") {
+    return error.name;
+  }
+  return null;
+}
+function serverError(body) {
+  if (body && typeof body === "object" && "error" in body && typeof body.error === "string") {
+    return body.error;
+  }
+  return null;
+}
+function messageContent(body) {
+  if (!body || typeof body !== "object" || !("message" in body)) return null;
+  const message = body.message;
+  if (!message || typeof message !== "object" || !("content" in message)) return null;
+  return typeof message.content === "string" ? message.content : null;
+}
+
+// src/commands/commit.ts
+var commitCommand = defineCommand({
+  meta: {
+    name: "commit",
+    description: "Stage all changes and commit with an LLM-generated Conventional Commits message."
+  },
+  args: {
+    model: {
+      type: "string",
+      alias: "m",
+      description: "Override the Ollama model (defaults to $OLLAMA_MODEL)."
+    },
+    type: {
+      type: "string",
+      alias: "t",
+      description: `Force the Conventional Commits type (${COMMIT_TYPES.join(", ")}).`
+    },
+    push: {
+      type: "boolean",
+      alias: "p",
+      description: "Push after committing without asking."
+    },
+    yes: {
+      type: "boolean",
+      alias: "y",
+      description: "Skip prompts and commit directly."
+    }
+  },
+  async run({ args }) {
+    const interactive = Boolean(process.stdin.isTTY && process.stdout.isTTY);
+    const config = resolveConfig(
+      process.env,
+      args.model ? { model: args.model } : {}
+    );
+    const type = args.type ? normalizeCommitType(args.type) : void 0;
+    if (type === null) {
+      log.error(
+        `Invalid type "${args.type}". Valid types: ${COMMIT_TYPES.join(", ")}.`
+      );
+      process.exitCode = 1;
+      return;
+    }
+    if (interactive) intro("zapdev commit");
+    await stageAll();
+    const diff = await getStagedDiff();
+    if (!diff.trim()) {
+      log.warn("Nothing to commit.");
+      if (interactive) outro("Nothing to do.");
+      return;
+    }
+    const loader = interactive ? spinner() : void 0;
+    loader?.start("Generating commit message");
+    let message;
+    try {
+      message = await generateCommitMessage(diff, config, type);
+    } catch (error) {
+      loader?.error("Generation failed");
+      log.error(`Generation failed: ${errorMessage(error)}`);
+      process.exitCode = 1;
+      return;
+    }
+    if (!message) {
+      loader?.error("Generation failed");
+      log.error("Generation failed: the model returned an empty message.");
+      process.exitCode = 1;
+      return;
+    }
+    if (loader) loader.stop(message);
+    else log.message(message);
+    let finalMessage = message;
+    if (interactive && !args.yes) {
+      const action = await select({
+        message: "Action",
+        initialValue: "commit",
+        options: [
+          { value: "commit", label: "Commit" },
+          { value: "edit", label: "Edit message" },
+          { value: "cancel", label: "Cancel" }
+        ]
+      });
+      if (isCancel(action) || action === "cancel") {
+        cancel("Cancelled (changes left staged).");
+        return;
+      }
+      if (action === "edit") {
+        const edited = await text({
+          message: "Edit message",
+          initialValue: message
+        });
+        if (isCancel(edited)) {
+          cancel("Cancelled (changes left staged).");
+          return;
+        }
+        finalMessage = edited.trim();
+        if (!finalMessage) {
+          cancel("Empty message, cancelled.");
+          return;
+        }
+      }
+    }
+    await commit(finalMessage);
+    if (interactive) log.success(`Committed: ${finalMessage}`);
+    let shouldPush = Boolean(args.push);
+    if (!shouldPush && interactive && !args.yes) {
+      const answer = await confirm({ message: "Push?", initialValue: false });
+      if (isCancel(answer)) {
+        if (interactive) outro("Committed. Not pushed.");
+        return;
+      }
+      shouldPush = answer;
+    }
+    if (shouldPush) {
+      const pushLoader = interactive ? spinner() : void 0;
+      pushLoader?.start("Pushing");
+      try {
+        const [upstream, branch] = await Promise.all([hasUpstream(), currentBranch()]);
+        if (upstream) await push();
+        else await pushSetUpstream(branch);
+        pushLoader?.stop("\u2713 Pushed");
+      } catch (error) {
+        pushLoader?.error("Push failed");
+        log.error(`Push failed: ${errorMessage(error)}`);
+        process.exitCode = 1;
+        return;
+      }
+    }
+    if (interactive) outro("Done.");
+  }
+});
+
+// src/cli.ts
+var commands = {
+  commit: commitCommand,
+  cleanup: cleanupCommand
+};
+var MENU = {
+  commit: "Stage all changes and commit with an AI-generated message",
+  cleanup: "Prune repos and delete stale local branches"
+};
+var menuOptions = Object.keys(MENU).map((value) => ({
+  value,
+  label: value,
+  hint: MENU[value]
+}));
+var main = defineCommand({
+  meta: {
+    name: "zapdev",
+    version: package_default.version,
+    description: "Fast, precise git chores from your terminal."
+  },
+  subCommands: commands,
+  // citty runs this after a matched subcommand too, so bail out when one already ran.
+  async run({ args, cmd }) {
+    const selected = args._[0];
+    if (selected && selected in commands) return;
+    if (!(process.stdin.isTTY && process.stdout.isTTY)) {
+      await showUsage(cmd);
+      return;
+    }
+    const choice = await select({ message: "Which command?", options: menuOptions });
+    if (isCancel(choice)) {
+      cancel("Cancelled.");
+      return;
+    }
+    await runCommand(commands[choice], { rawArgs: [] });
+  }
+});
+await runMain(main);