@donotdev/cli 0.0.14 → 0.0.16

package/dist/bin/commands/{lint.js → doctor.js}

@@ -4,11 +4,11 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
-  get: (a, b2) => (typeof require !== "undefined" ? require : a)[b2]
-}) : x)(function(x) {
+var __require = /* @__PURE__ */ ((x2) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x2, {
+  get: (a, b3) => (typeof require !== "undefined" ? require : a)[b3]
+}) : x2)(function(x2) {
   if (typeof require !== "undefined") return require.apply(this, arguments);
-  throw Error('Dynamic require of "' + x + '" is not supported');
+  throw Error('Dynamic require of "' + x2 + '" is not supported');
 });
 var __esm = (fn, res) => function __init() {
   return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
@@ -16,6 +16,10 @@ var __esm = (fn, res) => function __init() {
 var __commonJS = (cb, mod) => function __require2() {
   return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
 };
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
     for (let key of __getOwnPropNames(from))
@@ -42,16 +46,16 @@ var require_src = __commonJS({
     var CSI = `${ESC}[`;
     var beep = "\x07";
     var cursor = {
-      to(x, y2) {
-        if (!y2) return `${CSI}${x + 1}G`;
-        return `${CSI}${y2 + 1};${x + 1}H`;
+      to(x2, y3) {
+        if (!y3) return `${CSI}${x2 + 1}G`;
+        return `${CSI}${y3 + 1};${x2 + 1}H`;
       },
-      move(x, y2) {
+      move(x2, y3) {
         let ret = "";
-        if (x < 0) ret += `${CSI}${-x}D`;
-        else if (x > 0) ret += `${CSI}${x}C`;
-        if (y2 < 0) ret += `${CSI}${-y2}A`;
-        else if (y2 > 0) ret += `${CSI}${y2}B`;
+        if (x2 < 0) ret += `${CSI}${-x2}D`;
+        else if (x2 > 0) ret += `${CSI}${x2}C`;
+        if (y3 < 0) ret += `${CSI}${-y3}A`;
+        else if (y3 > 0) ret += `${CSI}${y3}B`;
         return ret;
       },
       up: (count = 1) => `${CSI}${count}A`,
@@ -94,10 +98,10 @@ var require_src = __commonJS({
 var require_picocolors = __commonJS({
   "node_modules/.bun/picocolors@1.1.1/node_modules/picocolors/picocolors.js"(exports, module) {
     init_utils();
-    var p = process || {};
-    var argv = p.argv || [];
-    var env = p.env || {};
-    var isColorSupported = !(!!env.NO_COLOR || argv.includes("--no-color")) && (!!env.FORCE_COLOR || argv.includes("--color") || p.platform === "win32" || (p.stdout || {}).isTTY && env.TERM !== "dumb" || !!env.CI);
+    var p2 = process || {};
+    var argv = p2.argv || [];
+    var env = p2.env || {};
+    var isColorSupported = !(!!env.NO_COLOR || argv.includes("--no-color")) && (!!env.FORCE_COLOR || argv.includes("--color") || p2.platform === "win32" || (p2.stdout || {}).isTTY && env.TERM !== "dumb" || !!env.CI);
     var formatter = (open, close, replace = open) => (input) => {
       let string = "" + input, index = string.indexOf(close, open.length);
       return ~index ? open + replaceClose(string, close, replace, index) + close : open + string + close;
@@ -165,14 +169,41 @@ var require_picocolors = __commonJS({
 
 // node_modules/.bun/@clack+prompts@0.11.0/node_modules/@clack/prompts/node_modules/@clack/core/dist/index.mjs
 import { stdin as j, stdout as M } from "node:process";
+import O from "node:readline";
 import { Writable as X } from "node:stream";
 function DD({ onlyFirst: e2 = false } = {}) {
   const t = ["[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]+)*|[a-zA-Z\\d]+(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?(?:\\u0007|\\u001B\\u005C|\\u009C))", "(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-nq-uy=><~]))"].join("|");
   return new RegExp(t, e2 ? void 0 : "g");
 }
+function P(e2) {
+  if (typeof e2 != "string") throw new TypeError(`Expected a \`string\`, got \`${typeof e2}\``);
+  return e2.replace(uD, "");
+}
 function L(e2) {
   return e2 && e2.__esModule && Object.prototype.hasOwnProperty.call(e2, "default") ? e2.default : e2;
 }
+function p(e2, u2 = {}) {
+  if (typeof e2 != "string" || e2.length === 0 || (u2 = { ambiguousIsNarrow: true, ...u2 }, e2 = P(e2), e2.length === 0)) return 0;
+  e2 = e2.replace(sD(), "  ");
+  const t = u2.ambiguousIsNarrow ? 1 : 2;
+  let F2 = 0;
+  for (const s of e2) {
+    const i = s.codePointAt(0);
+    if (i <= 31 || i >= 127 && i <= 159 || i >= 768 && i <= 879) continue;
+    switch (eD.eastAsianWidth(s)) {
+      case "F":
+      case "W":
+        F2 += 2;
+        break;
+      case "A":
+        F2 += t;
+        break;
+      default:
+        F2 += 1;
+    }
+  }
+  return F2;
+}
 function rD() {
   const e2 = /* @__PURE__ */ new Map();
   for (const [u2, t] of Object.entries(r)) {
@@ -202,7 +233,30 @@ function rD() {
     return i === 2 && (D2 += 60), D2;
   }, enumerable: false }, rgbToAnsi: { value: (u2, t, F2) => r.ansi256ToAnsi(r.rgbToAnsi256(u2, t, F2)), enumerable: false }, hexToAnsi: { value: (u2) => r.ansi256ToAnsi(r.hexToAnsi256(u2)), enumerable: false } }), r;
 }
-var import_sisteransi, uD, W, tD, eD, FD, sD, w, N, I, R, r, iD, CD, ED, nD, _, xD, B, AD, A;
+function Y(e2, u2, t) {
+  return String(e2).normalize().replace(/\r\n/g, `
+`).split(`
+`).map((F2) => lD(F2, u2, t)).join(`
+`);
+}
+function $(e2, u2) {
+  if (typeof e2 == "string") return B.aliases.get(e2) === u2;
+  for (const t of e2) if (t !== void 0 && $(t, u2)) return true;
+  return false;
+}
+function BD(e2, u2) {
+  if (e2 === u2) return;
+  const t = e2.split(`
+`), F2 = u2.split(`
+`), s = [];
+  for (let i = 0; i < Math.max(t.length, F2.length); i++) t[i] !== F2[i] && s.push(i);
+  return s;
+}
+function m(e2, u2) {
+  const t = e2;
+  t.isTTY && t.setRawMode(u2);
+}
+var import_sisteransi, uD, W, tD, eD, FD, sD, w, N, I, R, r, iD, CD, ED, d, oD, y, V, nD, G, _, z, K, aD, k, hD, lD, xD, B, AD, S, gD, vD, h, x, A, OD, PD, J, LD;
 var init_dist = __esm({
   "node_modules/.bun/@clack+prompts@0.11.0/node_modules/@clack/prompts/node_modules/@clack/core/dist/index.mjs"() {
     init_utils();
@@ -251,22 +305,213 @@ var init_dist = __esm({
     CD = Object.keys(r.bgColor);
     [...iD, ...CD];
     ED = rD();
+    d = /* @__PURE__ */ new Set(["\x1B", "\x9B"]);
+    oD = 39;
+    y = "\x07";
+    V = "[";
     nD = "]";
+    G = "m";
     _ = `${nD}8;;`;
+    z = (e2) => `${d.values().next().value}${V}${e2}${G}`;
+    K = (e2) => `${d.values().next().value}${_}${e2}${y}`;
+    aD = (e2) => e2.split(" ").map((u2) => p(u2));
+    k = (e2, u2, t) => {
+      const F2 = [...u2];
+      let s = false, i = false, D2 = p(P(e2[e2.length - 1]));
+      for (const [C2, n] of F2.entries()) {
+        const E = p(n);
+        if (D2 + E <= t ? e2[e2.length - 1] += n : (e2.push(n), D2 = 0), d.has(n) && (s = true, i = F2.slice(C2 + 1).join("").startsWith(_)), s) {
+          i ? n === y && (s = false, i = false) : n === G && (s = false);
+          continue;
+        }
+        D2 += E, D2 === t && C2 < F2.length - 1 && (e2.push(""), D2 = 0);
+      }
+      !D2 && e2[e2.length - 1].length > 0 && e2.length > 1 && (e2[e2.length - 2] += e2.pop());
+    };
+    hD = (e2) => {
+      const u2 = e2.split(" ");
+      let t = u2.length;
+      for (; t > 0 && !(p(u2[t - 1]) > 0); ) t--;
+      return t === u2.length ? e2 : u2.slice(0, t).join(" ") + u2.slice(t).join("");
+    };
+    lD = (e2, u2, t = {}) => {
+      if (t.trim !== false && e2.trim() === "") return "";
+      let F2 = "", s, i;
+      const D2 = aD(e2);
+      let C2 = [""];
+      for (const [E, a] of e2.split(" ").entries()) {
+        t.trim !== false && (C2[C2.length - 1] = C2[C2.length - 1].trimStart());
+        let o2 = p(C2[C2.length - 1]);
+        if (E !== 0 && (o2 >= u2 && (t.wordWrap === false || t.trim === false) && (C2.push(""), o2 = 0), (o2 > 0 || t.trim === false) && (C2[C2.length - 1] += " ", o2++)), t.hard && D2[E] > u2) {
+          const c = u2 - o2, f = 1 + Math.floor((D2[E] - c - 1) / u2);
+          Math.floor((D2[E] - 1) / u2) < f && C2.push(""), k(C2, a, u2);
+          continue;
+        }
+        if (o2 + D2[E] > u2 && o2 > 0 && D2[E] > 0) {
+          if (t.wordWrap === false && o2 < u2) {
+            k(C2, a, u2);
+            continue;
+          }
+          C2.push("");
+        }
+        if (o2 + D2[E] > u2 && t.wordWrap === false) {
+          k(C2, a, u2);
+          continue;
+        }
+        C2[C2.length - 1] += a;
+      }
+      t.trim !== false && (C2 = C2.map((E) => hD(E)));
+      const n = [...C2.join(`
+`)];
+      for (const [E, a] of n.entries()) {
+        if (F2 += a, d.has(a)) {
+          const { groups: c } = new RegExp(`(?:\\${V}(?<code>\\d+)m|\\${_}(?<uri>.*)${y})`).exec(n.slice(E).join("")) || { groups: {} };
+          if (c.code !== void 0) {
+            const f = Number.parseFloat(c.code);
+            s = f === oD ? void 0 : f;
+          } else c.uri !== void 0 && (i = c.uri.length === 0 ? void 0 : c.uri);
+        }
+        const o2 = ED.codes.get(Number(s));
+        n[E + 1] === `
+` ? (i && (F2 += K("")), s && o2 && (F2 += z(o2))) : a === `
+` && (s && o2 && (F2 += z(s)), i && (F2 += K(i)));
+      }
+      return F2;
+    };
     xD = ["up", "down", "left", "right", "space", "enter", "cancel"];
     B = { actions: new Set(xD), aliases: /* @__PURE__ */ new Map([["k", "up"], ["j", "down"], ["h", "left"], ["l", "right"], ["", "cancel"], ["escape", "cancel"]]) };
     AD = globalThis.process.platform.startsWith("win");
+    S = /* @__PURE__ */ Symbol("clack:cancel");
+    gD = Object.defineProperty;
+    vD = (e2, u2, t) => u2 in e2 ? gD(e2, u2, { enumerable: true, configurable: true, writable: true, value: t }) : e2[u2] = t;
+    h = (e2, u2, t) => (vD(e2, typeof u2 != "symbol" ? u2 + "" : u2, t), t);
+    x = class {
+      constructor(u2, t = true) {
+        h(this, "input"), h(this, "output"), h(this, "_abortSignal"), h(this, "rl"), h(this, "opts"), h(this, "_render"), h(this, "_track", false), h(this, "_prevFrame", ""), h(this, "_subscribers", /* @__PURE__ */ new Map()), h(this, "_cursor", 0), h(this, "state", "initial"), h(this, "error", ""), h(this, "value");
+        const { input: F2 = j, output: s = M, render: i, signal: D2, ...C2 } = u2;
+        this.opts = C2, this.onKeypress = this.onKeypress.bind(this), this.close = this.close.bind(this), this.render = this.render.bind(this), this._render = i.bind(this), this._track = t, this._abortSignal = D2, this.input = F2, this.output = s;
+      }
+      unsubscribe() {
+        this._subscribers.clear();
+      }
+      setSubscriber(u2, t) {
+        const F2 = this._subscribers.get(u2) ?? [];
+        F2.push(t), this._subscribers.set(u2, F2);
+      }
+      on(u2, t) {
+        this.setSubscriber(u2, { cb: t });
+      }
+      once(u2, t) {
+        this.setSubscriber(u2, { cb: t, once: true });
+      }
+      emit(u2, ...t) {
+        const F2 = this._subscribers.get(u2) ?? [], s = [];
+        for (const i of F2) i.cb(...t), i.once && s.push(() => F2.splice(F2.indexOf(i), 1));
+        for (const i of s) i();
+      }
+      prompt() {
+        return new Promise((u2, t) => {
+          if (this._abortSignal) {
+            if (this._abortSignal.aborted) return this.state = "cancel", this.close(), u2(S);
+            this._abortSignal.addEventListener("abort", () => {
+              this.state = "cancel", this.close();
+            }, { once: true });
+          }
+          const F2 = new X();
+          F2._write = (s, i, D2) => {
+            this._track && (this.value = this.rl?.line.replace(/\t/g, ""), this._cursor = this.rl?.cursor ?? 0, this.emit("value", this.value)), D2();
+          }, this.input.pipe(F2), this.rl = O.createInterface({ input: this.input, output: F2, tabSize: 2, prompt: "", escapeCodeTimeout: 50, terminal: true }), O.emitKeypressEvents(this.input, this.rl), this.rl.prompt(), this.opts.initialValue !== void 0 && this._track && this.rl.write(this.opts.initialValue), this.input.on("keypress", this.onKeypress), m(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), m(this.input, false), u2(this.value);
+          }), this.once("cancel", () => {
+            this.output.write(import_sisteransi.cursor.show), this.output.off("resize", this.render), m(this.input, false), u2(S);
+          });
+        });
+      }
+      onKeypress(u2, t) {
+        if (this.state === "error" && (this.state = "active"), t?.name && (!this._track && B.aliases.has(t.name) && this.emit("cursor", B.aliases.get(t.name)), B.actions.has(t.name) && this.emit("cursor", t.name)), u2 && (u2.toLowerCase() === "y" || u2.toLowerCase() === "n") && this.emit("confirm", u2.toLowerCase() === "y"), u2 === "	" && this.opts.placeholder && (this.value || (this.rl?.write(this.opts.placeholder), this.emit("value", this.opts.placeholder))), u2 && this.emit("key", u2.toLowerCase()), t?.name === "return") {
+          if (this.opts.validate) {
+            const F2 = this.opts.validate(this.value);
+            F2 && (this.error = F2 instanceof Error ? F2.message : F2, this.state = "error", this.rl?.write(this.value));
+          }
+          this.state !== "error" && (this.state = "submit");
+        }
+        $([u2, t?.name, t?.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(`
+`), m(this.input, false), this.rl?.close(), this.rl = void 0, this.emit(`${this.state}`, this.value), this.unsubscribe();
+      }
+      restoreCursor() {
+        const u2 = Y(this._prevFrame, process.stdout.columns, { hard: true }).split(`
+`).length - 1;
+        this.output.write(import_sisteransi.cursor.move(-999, u2 * -1));
+      }
+      render() {
+        const u2 = Y(this._render(this) ?? "", process.stdout.columns, { hard: true });
+        if (u2 !== this._prevFrame) {
+          if (this.state === "initial") this.output.write(import_sisteransi.cursor.hide);
+          else {
+            const t = BD(this._prevFrame, u2);
+            if (this.restoreCursor(), t && t?.length === 1) {
+              const F2 = t[0];
+              this.output.write(import_sisteransi.cursor.move(0, F2)), this.output.write(import_sisteransi.erase.lines(1));
+              const s = u2.split(`
+`);
+              this.output.write(s[F2]), this._prevFrame = u2, this.output.write(import_sisteransi.cursor.move(0, s.length - F2 - 1));
+              return;
+            }
+            if (t && t?.length > 1) {
+              const F2 = t[0];
+              this.output.write(import_sisteransi.cursor.move(0, F2)), this.output.write(import_sisteransi.erase.down());
+              const s = u2.split(`
+`).slice(F2);
+              this.output.write(s.join(`
+`)), this._prevFrame = u2;
+              return;
+            }
+            this.output.write(import_sisteransi.erase.down());
+          }
+          this.output.write(u2), this.state === "initial" && (this.state = "active"), this._prevFrame = u2;
+        }
+      }
+    };
     A = /* @__PURE__ */ new WeakMap();
+    OD = Object.defineProperty;
+    PD = (e2, u2, t) => u2 in e2 ? OD(e2, u2, { enumerable: true, configurable: true, writable: true, value: t }) : e2[u2] = t;
+    J = (e2, u2, t) => (PD(e2, typeof u2 != "symbol" ? u2 + "" : u2, t), t);
+    LD = class extends x {
+      constructor(u2) {
+        super(u2, false), J(this, "options"), J(this, "cursor", 0), this.options = u2.options, this.cursor = this.options.findIndex(({ value: t }) => t === u2.initialValue), this.cursor === -1 && (this.cursor = 0), this.changeValue(), this.on("cursor", (t) => {
+          switch (t) {
+            case "left":
+            case "up":
+              this.cursor = this.cursor === 0 ? this.options.length - 1 : this.cursor - 1;
+              break;
+            case "down":
+            case "right":
+              this.cursor = this.cursor === this.options.length - 1 ? 0 : this.cursor + 1;
+              break;
+          }
+          this.changeValue();
+        });
+      }
+      get _value() {
+        return this.options[this.cursor];
+      }
+      changeValue() {
+        this.value = this._value.value;
+      }
+    };
   }
 });
 
 // node_modules/.bun/@clack+prompts@0.11.0/node_modules/@clack/prompts/dist/index.mjs
-import { stripVTControlCharacters as S } from "node:util";
-import y from "node:process";
+import { stripVTControlCharacters as S2 } from "node:util";
+import y2 from "node:process";
 function ce() {
-  return y.platform !== "win32" ? y.env.TERM !== "linux" : !!y.env.CI || !!y.env.WT_SESSION || !!y.env.TERMINUS_SUBLIME || y.env.ConEmuTask === "{cmd::Cmder}" || y.env.TERM_PROGRAM === "Terminus-Sublime" || y.env.TERM_PROGRAM === "vscode" || y.env.TERM === "xterm-256color" || y.env.TERM === "alacritty" || y.env.TERMINAL_EMULATOR === "JetBrains-JediTerm";
+  return y2.platform !== "win32" ? y2.env.TERM !== "linux" : !!y2.env.CI || !!y2.env.WT_SESSION || !!y2.env.TERMINUS_SUBLIME || y2.env.ConEmuTask === "{cmd::Cmder}" || y2.env.TERM_PROGRAM === "Terminus-Sublime" || y2.env.TERM_PROGRAM === "vscode" || y2.env.TERM === "xterm-256color" || y2.env.TERM === "alacritty" || y2.env.TERMINAL_EMULATOR === "JetBrains-JediTerm";
 }
-var import_picocolors, import_sisteransi2, V, u, le, L2, W2, C, ue, o, d, k, P, A2, T, F, $e, _2, me, de, pe, q, D, U, K, M2, J;
+var import_picocolors, import_sisteransi2, V2, u, le, L2, W2, C, ue, o, d2, k2, P2, A2, T, F, $e, _2, me, de, pe, q, D, U, K2, b2, G2, ve, Me, Ie, Se, M2, J2;
 var init_dist2 = __esm({
   "node_modules/.bun/@clack+prompts@0.11.0/node_modules/@clack/prompts/dist/index.mjs"() {
     init_utils();
@@ -274,17 +519,17 @@ var init_dist2 = __esm({
     init_dist();
     import_picocolors = __toESM(require_picocolors(), 1);
     import_sisteransi2 = __toESM(require_src(), 1);
-    V = ce();
-    u = (t, n) => V ? t : n;
+    V2 = ce();
+    u = (t, n) => V2 ? t : n;
     le = u("\u25C6", "*");
     L2 = u("\u25A0", "x");
     W2 = u("\u25B2", "x");
     C = u("\u25C7", "o");
     ue = u("\u250C", "T");
     o = u("\u2502", "|");
-    d = u("\u2514", "\u2014");
-    k = u("\u25CF", ">");
-    P = u("\u25CB", " ");
+    d2 = u("\u2514", "\u2014");
+    k2 = u("\u25CF", ">");
+    P2 = u("\u25CB", " ");
     A2 = u("\u25FB", "[\u2022]");
     T = u("\u25FC", "[+]");
     F = u("\u25FB", "[ ]");
@@ -296,7 +541,87 @@ var init_dist2 = __esm({
     q = u("\u25CF", "\u2022");
     D = u("\u25C6", "*");
     U = u("\u25B2", "!");
-    K = u("\u25A0", "x");
+    K2 = u("\u25A0", "x");
+    b2 = (t) => {
+      switch (t) {
+        case "initial":
+        case "active":
+          return import_picocolors.default.cyan(le);
+        case "cancel":
+          return import_picocolors.default.red(L2);
+        case "error":
+          return import_picocolors.default.yellow(W2);
+        case "submit":
+          return import_picocolors.default.green(C);
+      }
+    };
+    G2 = (t) => {
+      const { cursor: n, options: r2, style: i } = t, s = t.maxItems ?? Number.POSITIVE_INFINITY, c = Math.max(process.stdout.rows - 4, 0), a = Math.min(c, Math.max(s, 5));
+      let l2 = 0;
+      n >= l2 + a - 3 ? l2 = Math.max(Math.min(n - a + 3, r2.length - a), 0) : n < l2 + 2 && (l2 = Math.max(n - 2, 0));
+      const $2 = a < r2.length && l2 > 0, g = a < r2.length && l2 + a < r2.length;
+      return r2.slice(l2, l2 + a).map((p2, v, f) => {
+        const j2 = v === 0 && $2, E = v === f.length - 1 && g;
+        return j2 || E ? import_picocolors.default.dim("...") : i(p2, v + l2 === n);
+      });
+    };
+    ve = (t) => {
+      const n = (r2, i) => {
+        const s = r2.label ?? String(r2.value);
+        switch (i) {
+          case "selected":
+            return `${import_picocolors.default.dim(s)}`;
+          case "active":
+            return `${import_picocolors.default.green(k2)} ${s} ${r2.hint ? import_picocolors.default.dim(`(${r2.hint})`) : ""}`;
+          case "cancelled":
+            return `${import_picocolors.default.strikethrough(import_picocolors.default.dim(s))}`;
+          default:
+            return `${import_picocolors.default.dim(P2)} ${import_picocolors.default.dim(s)}`;
+        }
+      };
+      return new LD({ options: t.options, initialValue: t.initialValue, render() {
+        const r2 = `${import_picocolors.default.gray(o)}
+${b2(this.state)}  ${t.message}
+`;
+        switch (this.state) {
+          case "submit":
+            return `${r2}${import_picocolors.default.gray(o)}  ${n(this.options[this.cursor], "selected")}`;
+          case "cancel":
+            return `${r2}${import_picocolors.default.gray(o)}  ${n(this.options[this.cursor], "cancelled")}
+${import_picocolors.default.gray(o)}`;
+          default:
+            return `${r2}${import_picocolors.default.cyan(o)}  ${G2({ cursor: this.cursor, options: this.options, maxItems: t.maxItems, style: (i, s) => n(i, s ? "active" : "inactive") }).join(`
+${import_picocolors.default.cyan(o)}  `)}
+${import_picocolors.default.cyan(d2)}
+`;
+        }
+      } }).prompt();
+    };
+    Me = (t = "", n = "") => {
+      const r2 = `
+${t}
+`.split(`
+`), i = S2(n).length, s = Math.max(r2.reduce((a, l2) => {
+        const $2 = S2(l2);
+        return $2.length > a ? $2.length : a;
+      }, 0), i) + 2, c = r2.map((a) => `${import_picocolors.default.gray(o)}  ${import_picocolors.default.dim(a)}${" ".repeat(s - S2(a).length)}${import_picocolors.default.gray(o)}`).join(`
+`);
+      process.stdout.write(`${import_picocolors.default.gray(o)}
+${import_picocolors.default.green(C)}  ${import_picocolors.default.reset(n)} ${import_picocolors.default.gray(_2.repeat(Math.max(s - i - 1, 1)) + me)}
+${c}
+${import_picocolors.default.gray(de + _2.repeat(s + 2) + pe)}
+`);
+    };
+    Ie = (t = "") => {
+      process.stdout.write(`${import_picocolors.default.gray(ue)}  ${t}
+`);
+    };
+    Se = (t = "") => {
+      process.stdout.write(`${import_picocolors.default.gray(o)}
+${import_picocolors.default.gray(d2)}  ${t}
+
+`);
+    };
     M2 = { message: (t = "", { symbol: n = import_picocolors.default.gray(o) } = {}) => {
       const r2 = [`${import_picocolors.default.gray(o)}`];
       if (t) {
@@ -318,9 +643,9 @@ var init_dist2 = __esm({
     }, warning: (t) => {
       M2.warn(t);
     }, error: (t) => {
-      M2.message(t, { symbol: import_picocolors.default.red(K) });
+      M2.message(t, { symbol: import_picocolors.default.red(K2) });
     } };
-    J = `${import_picocolors.default.gray(o)}  `;
+    J2 = `${import_picocolors.default.gray(o)}  `;
   }
 });
 
@@ -934,8 +1259,8 @@ var require_to_regex_range = __commonJS({
         return toRegexRange.cache[cacheKey].result;
       }
       let a = Math.min(min, max);
-      let b2 = Math.max(min, max);
-      if (Math.abs(a - b2) === 1) {
+      let b3 = Math.max(min, max);
+      if (Math.abs(a - b3) === 1) {
         let result = min + "|" + max;
         if (opts.capture) {
           return `(${result})`;
@@ -946,7 +1271,7 @@ var require_to_regex_range = __commonJS({
         return `(?:${result})`;
       }
       let isPadded = hasPadding(min) || hasPadding(max);
-      let state = { min, max, a, b: b2 };
+      let state = { min, max, a, b: b3 };
       let positives = [];
       let negatives = [];
       if (isPadded) {
@@ -954,12 +1279,12 @@ var require_to_regex_range = __commonJS({
         state.maxLen = String(state.max).length;
       }
       if (a < 0) {
-        let newMin = b2 < 0 ? Math.abs(b2) : 1;
+        let newMin = b3 < 0 ? Math.abs(b3) : 1;
         negatives = splitToPatterns(newMin, Math.abs(a), state, opts);
         a = state.a = 0;
       }
-      if (b2 >= 0) {
-        positives = splitToPatterns(a, b2, state, opts);
+      if (b3 >= 0) {
+        positives = splitToPatterns(a, b3, state, opts);
       }
       state.negatives = negatives;
       state.positives = positives;
@@ -1063,13 +1388,13 @@ var require_to_regex_range = __commonJS({
       }
       return result;
     }
-    function zip(a, b2) {
+    function zip(a, b3) {
       let arr = [];
-      for (let i = 0; i < a.length; i++) arr.push([a[i], b2[i]]);
+      for (let i = 0; i < a.length; i++) arr.push([a[i], b3[i]]);
       return arr;
     }
-    function compare(a, b2) {
-      return a > b2 ? 1 : b2 > a ? -1 : 0;
+    function compare(a, b3) {
+      return a > b3 ? 1 : b3 > a ? -1 : 0;
     }
     function contains(arr, key, val) {
       return arr.some((ele) => ele[key] === val);
@@ -1087,8 +1412,8 @@ var require_to_regex_range = __commonJS({
       }
       return "";
     }
-    function toCharacterClass(a, b2, options) {
-      return `[${a}${b2 - a === 1 ? "" : "-"}${b2}]`;
+    function toCharacterClass(a, b3, options) {
+      return `[${a}${b3 - a === 1 ? "" : "-"}${b3}]`;
     }
     function hasPadding(str) {
       return /^-?(0+)\d/.test(str);
@@ -1167,8 +1492,8 @@ var require_fill_range = __commonJS({
       return negative ? "-" + input : input;
     };
     var toSequence = (parts, options, maxLen) => {
-      parts.negatives.sort((a, b2) => a < b2 ? -1 : a > b2 ? 1 : 0);
-      parts.positives.sort((a, b2) => a < b2 ? -1 : a > b2 ? 1 : 0);
+      parts.negatives.sort((a, b3) => a < b3 ? -1 : a > b3 ? 1 : 0);
+      parts.positives.sort((a, b3) => a < b3 ? -1 : a > b3 ? 1 : 0);
       let prefix = options.capture ? "" : "?:";
       let positives = "";
       let negatives = "";
@@ -1189,13 +1514,13 @@ var require_fill_range = __commonJS({
       }
       return result;
     };
-    var toRange = (a, b2, isNumbers, options) => {
+    var toRange = (a, b3, isNumbers, options) => {
       if (isNumbers) {
-        return toRegexRange(a, b2, { wrap: false, ...options });
+        return toRegexRange(a, b3, { wrap: false, ...options });
       }
       let start = String.fromCharCode(a);
-      if (a === b2) return start;
-      let stop = String.fromCharCode(b2);
+      if (a === b3) return start;
+      let stop = String.fromCharCode(b3);
       return `[${start}-${stop}]`;
     };
     var toRegex = (start, end, options) => {
@@ -1221,14 +1546,14 @@ var require_fill_range = __commonJS({
     };
     var fillNumbers = (start, end, step = 1, options = {}) => {
       let a = Number(start);
-      let b2 = Number(end);
-      if (!Number.isInteger(a) || !Number.isInteger(b2)) {
+      let b3 = Number(end);
+      if (!Number.isInteger(a) || !Number.isInteger(b3)) {
         if (options.strictRanges === true) throw rangeError([start, end]);
         return [];
       }
       if (a === 0) a = 0;
-      if (b2 === 0) b2 = 0;
-      let descending = a > b2;
+      if (b3 === 0) b3 = 0;
+      let descending = a > b3;
       let startString = String(start);
       let endString = String(end);
       let stepString = String(step);
@@ -1244,7 +1569,7 @@ var require_fill_range = __commonJS({
       let push = (num) => parts[num < 0 ? "negatives" : "positives"].push(Math.abs(num));
       let range = [];
       let index = 0;
-      while (descending ? a >= b2 : a <= b2) {
+      while (descending ? a >= b3 : a <= b3) {
         if (options.toRegex === true && step > 1) {
           push(a);
         } else {
@@ -1264,16 +1589,16 @@ var require_fill_range = __commonJS({
       }
       let format = options.transform || ((val) => String.fromCharCode(val));
       let a = `${start}`.charCodeAt(0);
-      let b2 = `${end}`.charCodeAt(0);
-      let descending = a > b2;
-      let min = Math.min(a, b2);
-      let max = Math.max(a, b2);
+      let b3 = `${end}`.charCodeAt(0);
+      let descending = a > b3;
+      let min = Math.min(a, b3);
+      let max = Math.max(a, b3);
       if (options.toRegex && step === 1) {
         return toRange(min, max, false, options);
       }
       let range = [];
       let index = 0;
-      while (descending ? a >= b2 : a <= b2) {
+      while (descending ? a >= b3 : a <= b3) {
         range.push(format(a, index));
         a = descending ? a - step : a + step;
         index++;
@@ -1398,11 +1723,11 @@ var require_expand = __commonJS({
       const rangeLimit = options.rangeLimit === void 0 ? 1e3 : options.rangeLimit;
       const walk = (node, parent = {}) => {
         node.queue = [];
-        let p = parent;
+        let p2 = parent;
         let q2 = parent.queue;
-        while (p.type !== "brace" && p.type !== "root" && p.parent) {
-          p = p.parent;
-          q2 = p.queue;
+        while (p2.type !== "brace" && p2.type !== "root" && p2.parent) {
+          p2 = p2.parent;
+          q2 = p2.queue;
         }
         if (node.invalid || node.dollar) {
           q2.push(append(q2.pop(), stringify2(node, options)));
@@ -2646,10 +2971,10 @@ var require_parse2 = __commonJS({
       };
       if (opts.fastpaths !== false && !/(^[*!]|[/()[\]{}"])/.test(input)) {
         let backslashes = false;
-        let output = input.replace(REGEX_SPECIAL_CHARS_BACKREF, (m, esc, chars, first, rest, index) => {
+        let output = input.replace(REGEX_SPECIAL_CHARS_BACKREF, (m2, esc, chars, first, rest, index) => {
           if (first === "\\") {
             backslashes = true;
-            return m;
+            return m2;
           }
           if (first === "?") {
             if (esc) {
@@ -2669,14 +2994,14 @@ var require_parse2 = __commonJS({
             }
             return star;
           }
-          return esc ? m : `\\${m}`;
+          return esc ? m2 : `\\${m2}`;
         });
         if (backslashes === true) {
           if (opts.unescape === true) {
             output = output.replace(/\\/g, "");
           } else {
-            output = output.replace(/\\+/g, (m) => {
-              return m.length % 2 === 0 ? "\\\\" : m ? "\\" : "";
+            output = output.replace(/\\+/g, (m2) => {
+              return m2.length % 2 === 0 ? "\\\\" : m2 ? "\\" : "";
             });
           }
         }
@@ -3323,7 +3648,7 @@ var require_picomatch = __commonJS({
     };
     picomatch.isMatch = (str, patterns, options) => picomatch(patterns, options)(str);
     picomatch.parse = (pattern, options) => {
-      if (Array.isArray(pattern)) return pattern.map((p) => picomatch.parse(p, options));
+      if (Array.isArray(pattern)) return pattern.map((p2) => picomatch.parse(p2, options));
       return parse2(pattern, { ...options, fastpaths: false });
     };
     picomatch.scan = (input, options) => scan(input, options);
@@ -3430,7 +3755,7 @@ var require_micromatch = __commonJS({
           throw new Error(`No matches found for "${patterns.join(", ")}"`);
         }
         if (options.nonull === true || options.nullglob === true) {
-          return options.unescape ? patterns.map((p) => p.replace(/\\/g, "")) : patterns;
+          return options.unescape ? patterns.map((p2) => p2.replace(/\\/g, "")) : patterns;
         }
       }
       return matches;
@@ -3460,7 +3785,7 @@ var require_micromatch = __commonJS({
         throw new TypeError(`Expected a string: "${util.inspect(str)}"`);
       }
       if (Array.isArray(pattern)) {
-        return pattern.some((p) => micromatch.contains(str, p, options));
+        return pattern.some((p2) => micromatch.contains(str, p2, options));
       }
       if (typeof pattern === "string") {
         if (isEmptyString(str) || isEmptyString(pattern)) {
@@ -3505,7 +3830,7 @@ var require_micromatch = __commonJS({
       if (typeof str !== "string") {
         throw new TypeError(`Expected a string: "${util.inspect(str)}"`);
       }
-      return [].concat(patterns).every((p) => picomatch(p, options)(str));
+      return [].concat(patterns).every((p2) => picomatch(p2, options)(str));
     };
     micromatch.capture = (glob, input, options) => {
       let posix = utils.isWindows(options);
@@ -3656,7 +3981,7 @@ var require_pattern = __commonJS({
     exports.expandPatternsWithBraceExpansion = expandPatternsWithBraceExpansion;
     function expandBraceExpansion(pattern) {
       const patterns = micromatch.braces(pattern, { expand: true, nodupes: true, keepEscaping: true });
-      patterns.sort((a, b2) => a.length - b2.length);
+      patterns.sort((a, b3) => a.length - b3.length);
       return patterns.filter((pattern2) => pattern2 !== "");
     }
     exports.expandBraceExpansion = expandBraceExpansion;
@@ -4129,11 +4454,11 @@ var require_out = __commonJS({
       async.read(path, getSettings(optionsOrSettingsOrCallback), callback);
     }
     exports.stat = stat;
-    function statSync2(path, optionsOrSettings) {
+    function statSync3(path, optionsOrSettings) {
       const settings = getSettings(optionsOrSettings);
       return sync.read(path, settings);
     }
-    exports.statSync = statSync2;
+    exports.statSync = statSync3;
     function getSettings(settingsOrOptions = {}) {
       if (settingsOrOptions instanceof settings_1.default) {
         return settingsOrOptions;
@@ -4271,11 +4596,11 @@ var require_common = __commonJS({
     init_utils();
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.joinPathSegments = void 0;
-    function joinPathSegments(a, b2, separator) {
+    function joinPathSegments(a, b3, separator) {
       if (a.endsWith(separator)) {
-        return a + b2;
+        return a + b3;
       }
-      return a + separator + b2;
+      return a + separator + b3;
     }
     exports.joinPathSegments = joinPathSegments;
   }
@@ -4811,7 +5136,7 @@ var require_queue = __commonJS({
       queue.drained = drained;
       return queue;
       function push(value) {
-        var p = new Promise(function(resolve4, reject) {
+        var p2 = new Promise(function(resolve4, reject) {
           pushCb(value, function(err, result) {
             if (err) {
               reject(err);
@@ -4820,11 +5145,11 @@ var require_queue = __commonJS({
             resolve4(result);
           });
         });
-        p.catch(noop);
-        return p;
+        p2.catch(noop);
+        return p2;
       }
       function unshift(value) {
-        var p = new Promise(function(resolve4, reject) {
+        var p2 = new Promise(function(resolve4, reject) {
           unshiftCb(value, function(err, result) {
             if (err) {
               reject(err);
@@ -4833,11 +5158,11 @@ var require_queue = __commonJS({
             resolve4(result);
           });
         });
-        p.catch(noop);
-        return p;
+        p2.catch(noop);
+        return p2;
       }
       function drained() {
-        var p = new Promise(function(resolve4) {
+        var p2 = new Promise(function(resolve4) {
           process.nextTick(function() {
             if (queue.idle()) {
               resolve4();
@@ -4851,7 +5176,7 @@ var require_queue = __commonJS({
             }
           });
         });
-        return p;
+        return p2;
       }
     }
     module.exports = fastqueue;
@@ -4881,14 +5206,14 @@ var require_common2 = __commonJS({
       return filepath.split(/[/\\]/).join(separator);
     }
     exports.replacePathSegmentSeparator = replacePathSegmentSeparator;
-    function joinPathSegments(a, b2, separator) {
+    function joinPathSegments(a, b3, separator) {
       if (a === "") {
-        return b2;
+        return b3;
       }
       if (a.endsWith(separator)) {
-        return a + b2;
+        return a + b3;
       }
-      return a + separator + b2;
+      return a + separator + b3;
     }
     exports.joinPathSegments = joinPathSegments;
   }
@@ -7215,11 +7540,39 @@ var init_PathResolver = __esm({
 });
 
 // packages/tooling/src/utils/errors.ts
-var DoNotDevError;
+var DO_NOT_DEV_ERROR_CODES, DoNotDevError;
 var init_errors = __esm({
   "packages/tooling/src/utils/errors.ts"() {
     "use strict";
     init_utils();
+    DO_NOT_DEV_ERROR_CODES = {
+      CONFIGURATION_ERROR: "configuration-error",
+      CONFIG_NOT_FOUND: "config-not-found",
+      CONFIG_INVALID: "config-invalid",
+      PATH_RESOLUTION_ERROR: "path-resolution-error",
+      FILE_OPERATION_ERROR: "file-operation-error",
+      FILE_NOT_FOUND: "file-not-found",
+      PERMISSION_DENIED: "permission-denied",
+      GENERATION_ERROR: "generation-error",
+      TEMPLATE_ERROR: "template-error",
+      TEMPLATE_NOT_FOUND: "template-not-found",
+      CLI_EXECUTION_ERROR: "cli-execution-error",
+      COMMAND_NOT_FOUND: "command-not-found",
+      COMMAND_FAILED: "command-failed",
+      VALIDATION_ERROR: "validation-error",
+      SCHEMA_ERROR: "schema-error",
+      DEPENDENCY_ERROR: "dependency-error",
+      DEPENDENCY_NOT_FOUND: "dependency-not-found",
+      DEPENDENCY_VERSION_ERROR: "dependency-version-error",
+      INVALID_ARGUMENT: "invalid-argument",
+      MISSING_ARGUMENT: "missing-argument",
+      MISSING_PROJECT_ID: "missing-project-id",
+      FIREBASE_CLI_ERROR: "firebase-cli-error",
+      DEPLOYMENT_FAILED: "deployment-failed",
+      OPERATION_CANCELLED: "operation-cancelled",
+      TIMEOUT_ERROR: "timeout-error",
+      UNKNOWN_ERROR: "unknown-error"
+    };
     DoNotDevError = class _DoNotDevError extends Error {
       /** The error code categorizing this error */
       code;
@@ -7239,7 +7592,7 @@ var init_errors = __esm({
        * @param {Record<string, any>} [options.context] - Additional context data
        * @param {boolean} [options.displayable=true] - Whether this error should be displayed to the user
        */
-      constructor(message, code = "unknown-error", options) {
+      constructor(message, code = DO_NOT_DEV_ERROR_CODES.UNKNOWN_ERROR, options) {
         super(message);
         this.name = "DoNotDevError";
         this.code = code;
@@ -7270,7 +7623,7 @@ var init_errors = __esm({
        * @param {boolean} [options.displayable=true] - Whether this error should be displayed to the user
        * @returns {DoNotDevError} New DoNotDev error wrapping the original
        */
-      static from(error2, context, code = "unknown-error", options) {
+      static from(error2, context, code = DO_NOT_DEV_ERROR_CODES.UNKNOWN_ERROR, options) {
         if (!(error2 instanceof Error)) {
           return new _DoNotDevError(
             `Unknown error: ${String(error2)}`,
@@ -7307,21 +7660,21 @@ var init_errors = __esm({
         }
         const message = error2.message.toLowerCase();
         if (error2.name === "ValidationError" || message.includes("validation")) {
-          return "validation-error";
+          return DO_NOT_DEV_ERROR_CODES.VALIDATION_ERROR;
         }
         if (message.includes("not found") || message.includes("no such file")) {
-          return "file-not-found";
+          return DO_NOT_DEV_ERROR_CODES.FILE_NOT_FOUND;
         }
         if (message.includes("permission") || message.includes("access denied")) {
-          return "permission-denied";
+          return DO_NOT_DEV_ERROR_CODES.PERMISSION_DENIED;
         }
         if (message.includes("timeout") || message.includes("timed out")) {
-          return "timeout-error";
+          return DO_NOT_DEV_ERROR_CODES.TIMEOUT_ERROR;
         }
         if (message.includes("dependency") || message.includes("module not found")) {
-          return "dependency-error";
+          return DO_NOT_DEV_ERROR_CODES.DEPENDENCY_ERROR;
         }
-        return "unknown-error";
+        return DO_NOT_DEV_ERROR_CODES.UNKNOWN_ERROR;
       }
     };
   }
@@ -7340,7 +7693,10 @@ import {
   isAbsolute as pathIsAbsolute
 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
-var pathResolverInstance, normalizePath, pathExists, joinPath;
+function readdirSync2(dirPath, options) {
+  return pathResolverInstance.readdirSync(dirPath, options);
+}
+var pathResolverInstance, normalizePath, pathExists, readSync, statSync2, joinPath;
 var init_pathResolver = __esm({
   "packages/tooling/src/utils/pathResolver.ts"() {
     "use strict";
@@ -7351,12 +7707,42 @@ var init_pathResolver = __esm({
       return pathResolverInstance.normalizePath(join2(...pathSegments));
     };
     pathExists = (filePath, silent = false) => pathResolverInstance.pathExists(filePath, silent);
+    readSync = (filePath, options) => pathResolverInstance.readSync(filePath, options);
+    statSync2 = (filePath) => pathResolverInstance.statSync(filePath);
     joinPath = (...pathSegments) => {
       return normalizePath(...pathSegments);
     };
   }
 });
 
+// packages/tooling/src/utils/typed-file-operations.ts
+function readPackageJson(filePath) {
+  if (!pathExists(filePath)) {
+    throw new DoNotDevError(
+      `package.json not found: ${filePath}`,
+      DO_NOT_DEV_ERROR_CODES.FILE_NOT_FOUND,
+      { context: { filePath } }
+    );
+  }
+  const content = readSync(filePath, { format: "json" });
+  if (!content || typeof content !== "object" || !("name" in content)) {
+    throw new DoNotDevError(
+      `Invalid package.json: ${filePath}`,
+      DO_NOT_DEV_ERROR_CODES.CONFIG_INVALID,
+      { context: { filePath } }
+    );
+  }
+  return content;
+}
+var init_typed_file_operations = __esm({
+  "packages/tooling/src/utils/typed-file-operations.ts"() {
+    "use strict";
+    init_utils();
+    init_pathResolver();
+    init_errors();
+  }
+});
+
 // packages/tooling/src/bundler/utils.ts
 import { Buffer as Buffer2 } from "node:buffer";
 import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2 } from "node:fs";
@@ -7384,77 +7770,750 @@ var init_utils = __esm({
   }
 });
 
-// packages/cli/src/bin/commands/lint.ts
-init_utils();
+// packages/tooling/src/utils/app-detection.ts
+function detectApps(projectRoot) {
+  const apps = [];
+  const appsDir = joinPath(projectRoot, "apps");
+  const appsDirStat = statSync2(appsDir);
+  if (pathExists(appsDir) && appsDirStat?.isDirectory()) {
+    const appDirs = readdirSync2(appsDir, { withFileTypes: true }).filter((dirent) => dirent.isDirectory()).map((dirent) => dirent.name).sort();
+    for (const appDir of appDirs) {
+      const appPath = joinPath(appsDir, appDir);
+      const packageJsonPath = joinPath(appPath, "package.json");
+      if (pathExists(packageJsonPath)) {
+        const appInfo = analyzeApp(appPath, appDir);
+        if (appInfo) {
+          apps.push(appInfo);
+        }
+      }
+    }
+  } else {
+    const packageJsonPath = joinPath(projectRoot, "package.json");
+    if (pathExists(packageJsonPath)) {
+      try {
+        const packageJson = readPackageJson(packageJsonPath);
+        if (packageJson && (packageJson.dependencies?.vite || packageJson.devDependencies?.vite || packageJson.dependencies?.next || packageJson.devDependencies?.next)) {
+          const pathParts = projectRoot.split(/[/\\]/);
+          const appName = pathParts[pathParts.length - 1] || "app";
+          const appInfo = analyzeApp(projectRoot, appName);
+          if (appInfo) {
+            apps.push(appInfo);
+          }
+        }
+      } catch {
+      }
+    }
+  }
+  return apps;
+}
+function analyzeApp(appPath, appName) {
+  const packageJsonPath = joinPath(appPath, "package.json");
+  if (!pathExists(packageJsonPath)) {
+    return null;
+  }
+  let packageJson = null;
+  try {
+    packageJson = readPackageJson(packageJsonPath);
+    if (!packageJson.name) {
+      return null;
+    }
+  } catch {
+    return null;
+  }
+  let framework = "unknown";
+  if (pathExists(joinPath(appPath, "next.config.js")) || pathExists(joinPath(appPath, "next.config.ts")) || pathExists(joinPath(appPath, "next.config.mjs")) || packageJson.dependencies?.next || packageJson.devDependencies?.next) {
+    framework = "nextjs";
+  } else if (pathExists(joinPath(appPath, "vite.config.ts")) || pathExists(joinPath(appPath, "vite.config.js")) || pathExists(joinPath(appPath, "vite.config.mjs")) || packageJson.dependencies?.vite || packageJson.devDependencies?.vite) {
+    framework = "vite";
+  }
+  const functionsPath = joinPath(appPath, "functions");
+  const functionsStat = statSync2(functionsPath);
+  const hasFunctions = pathExists(functionsPath) && (functionsStat?.isDirectory() ?? false);
+  let platform;
+  const firebaseJsonInFunctions = hasFunctions && pathExists(joinPath(functionsPath, "firebase.json"));
+  const firebaseJsonInApp = pathExists(joinPath(appPath, "firebase.json"));
+  if (firebaseJsonInFunctions || firebaseJsonInApp) {
+    platform = "firebase";
+  }
+  if (!platform) {
+    const supabaseConfigPath = joinPath(appPath, "supabase", "config.toml");
+    const hasSupabaseDep = !!(packageJson.dependencies?.["@donotdev/supabase"] || packageJson.dependencies?.["@supabase/supabase-js"]);
+    if (pathExists(supabaseConfigPath) || hasSupabaseDep) {
+      platform = "supabase";
+    }
+  }
+  if (!platform) {
+    const vercelJsonPath = joinPath(appPath, "vercel.json");
+    if (pathExists(vercelJsonPath)) {
+      platform = "vercel";
+    }
+  }
+  return {
+    name: appName,
+    packageName: packageJson.name || appName,
+    path: appPath,
+    packageJsonPath,
+    framework,
+    hasFunctions,
+    functionsPath: hasFunctions ? functionsPath : void 0,
+    platform
+  };
+}
+var init_app_detection = __esm({
+  "packages/tooling/src/utils/app-detection.ts"() {
+    "use strict";
+    init_utils();
+    init_pathResolver();
+    init_typed_file_operations();
+  }
+});
 
-// packages/tooling/src/index.ts
-init_utils();
+// packages/tooling/src/utils/app-selector.ts
+async function selectApp(projectRoot, appName) {
+  const apps = detectApps(projectRoot);
+  if (apps.length === 0) {
+    log.error("No apps found in this project.");
+    log.info('Run "dndev init" to create a new project.');
+    return null;
+  }
+  if (appName) {
+    const app = apps.find((a) => a.name === appName);
+    if (!app) {
+      log.warn(`App "${appName}" not found.`);
+      log.info("Available apps:");
+      apps.forEach((a) => log.info(`  - ${a.name}`));
+      log.info("Please select from the list:");
+    } else {
+      return app;
+    }
+  }
+  if (apps.length === 1) {
+    return apps[0] || null;
+  }
+  const selected = await ve({
+    message: "Select app:",
+    options: apps.map((app) => ({
+      value: app.name,
+      label: `${app.name} (${app.framework === "nextjs" ? "Next.js" : "Vite"}${app.hasFunctions ? ` + ${app.platform || "functions"}` : ""})`
+    }))
+  });
+  if (typeof selected !== "string") {
+    return null;
+  }
+  return apps.find((a) => a.name === selected) || null;
+}
+var init_app_selector = __esm({
+  "packages/tooling/src/utils/app-selector.ts"() {
+    "use strict";
+    init_utils();
+    init_dist2();
+    init_app_detection();
+    init_cli_output();
+  }
+});
 
-// packages/tooling/src/cli/index.ts
-init_utils();
+// packages/tooling/src/cli/doctor/check-env.ts
+var check_env_exports = {};
+__export(check_env_exports, {
+  envCheck: () => envCheck,
+  parseEnvFile: () => parseEnvFile
+});
+function parseEnvFile(filePath) {
+  const map = /* @__PURE__ */ new Map();
+  if (!pathExists(filePath)) return map;
+  const content = readSync(filePath, { format: "text" });
+  if (typeof content !== "string") return map;
+  for (const line of content.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const eqIdx = trimmed.indexOf("=");
+    if (eqIdx < 0) continue;
+    const key = trimmed.substring(0, eqIdx).trim();
+    const value = trimmed.substring(eqIdx + 1).trim();
+    if (key) map.set(key, value);
+  }
+  return map;
+}
+var envCheck;
+var init_check_env = __esm({
+  "packages/tooling/src/cli/doctor/check-env.ts"() {
+    "use strict";
+    init_utils();
+    init_pathResolver();
+    envCheck = {
+      id: "env",
+      name: "Environment Files",
+      isRelevant(_ctx) {
+        return true;
+      },
+      async run(ctx) {
+        const results = [];
+        const envPath = joinPath(ctx.appDir, ".env");
+        const examplePath = joinPath(ctx.appDir, ".env.example");
+        if (!pathExists(envPath)) {
+          results.push({ name: ".env file", status: "fail", message: "Not found \u2014 run dndev setup" });
+          return results;
+        }
+        results.push({ name: ".env file", status: "pass", message: "Found" });
+        if (pathExists(examplePath)) {
+          const example = parseEnvFile(examplePath);
+          const actual = parseEnvFile(envPath);
+          const missing = [];
+          const empty = [];
+          for (const [key] of example) {
+            if (!actual.has(key)) {
+              missing.push(key);
+            } else if (!actual.get(key)) {
+              empty.push(key);
+            }
+          }
+          if (missing.length > 0) {
+            results.push({
+              name: "Missing vars",
+              status: "fail",
+              message: `${missing.length} var(s) in .env.example not in .env: ${missing.join(", ")}`
+            });
+          }
+          if (empty.length > 0) {
+            results.push({
+              name: "Empty vars",
+              status: "warn",
+              message: `${empty.length} var(s) are empty: ${empty.join(", ")}`
+            });
+          }
+          if (missing.length === 0 && empty.length === 0) {
+            results.push({
+              name: ".env vs .env.example",
+              status: "pass",
+              message: `All ${example.size} expected vars present`
+            });
+          }
+        }
+        const gitignorePath = joinPath(ctx.projectRoot, ".gitignore");
+        if (pathExists(gitignorePath)) {
+          const content = readSync(gitignorePath, { format: "text" });
+          if (typeof content === "string") {
+            const hasEnvIgnore = content.split("\n").some((line) => {
+              const trimmed = line.trim();
+              if (!trimmed || trimmed.startsWith("#")) return false;
+              return /^\.env(\*|\..*)?$/.test(trimmed);
+            });
+            if (hasEnvIgnore) {
+              results.push({ name: ".gitignore", status: "pass", message: ".env is gitignored" });
+            } else {
+              results.push({ name: ".gitignore", status: "warn", message: ".env might not be gitignored \u2014 verify manually" });
+            }
+          }
+        }
+        return results;
+      }
+    };
+  }
+});
 
-// packages/tooling/src/quality/lint.ts
-init_utils();
-init_cli_output();
-init_errors();
-init_pathResolver();
+// packages/tooling/src/cli/doctor/check-firebase.ts
+var check_firebase_exports = {};
+__export(check_firebase_exports, {
+  firebaseCheck: () => firebaseCheck
+});
 import { spawnSync } from "node:child_process";
-async function main(options = {}) {
-  const fix = options.fix ?? false;
-  const cwd = process.cwd();
-  const eslintConfigs = [
-    "eslint.config.js",
-    "eslint.config.mjs",
-    "eslint.config.cjs"
-  ];
-  const hasEslintConfig = eslintConfigs.some(
-    (config) => pathExists(joinPath(cwd, config))
-  );
-  if (!hasEslintConfig) {
-    log.info("No eslint.config.js found in current directory. Skipping lint.");
-    log.info("To enable linting, create an eslint.config.js file.");
-    return 0;
+var firebaseCheck;
+var init_check_firebase = __esm({
+  "packages/tooling/src/cli/doctor/check-firebase.ts"() {
+    "use strict";
+    init_utils();
+    init_pathResolver();
+    firebaseCheck = {
+      id: "firebase",
+      name: "Firebase",
+      isRelevant(ctx) {
+        return pathExists(joinPath(ctx.appDir, "firebase.json")) || pathExists(joinPath(ctx.projectRoot, "firebase.json")) || pathExists(joinPath(ctx.projectRoot, ".firebaserc"));
+      },
+      async run(ctx) {
+        const results = [];
+        try {
+          const result = spawnSync("firebase", ["--version"], {
+            stdio: "pipe",
+            encoding: "utf-8",
+            timeout: 1e4
+          });
+          if (result.status === 0) {
+            results.push({ name: "Firebase CLI", status: "pass", message: result.stdout.trim() });
+          } else {
+            results.push({ name: "Firebase CLI", status: "fail", message: "Not installed" });
+          }
+        } catch {
+          results.push({ name: "Firebase CLI", status: "fail", message: "Not installed" });
+        }
+        const rcPath = joinPath(ctx.projectRoot, ".firebaserc");
+        if (pathExists(rcPath)) {
+          try {
+            const raw = readSync(rcPath, { format: "text" });
+            if (typeof raw !== "string") throw new Error("Not a string");
+            const rc = JSON.parse(raw);
+            const projects = rc?.projects;
+            const projectId = projects && typeof projects === "object" ? projects.default : void 0;
+            if (projectId && typeof projectId === "string") {
+              results.push({ name: ".firebaserc", status: "pass", message: `Project: ${projectId}` });
+            } else {
+              results.push({ name: ".firebaserc", status: "warn", message: "No default project set" });
+            }
+          } catch {
+            results.push({ name: ".firebaserc", status: "warn", message: "Invalid JSON" });
+          }
+        } else {
+          results.push({ name: ".firebaserc", status: "fail", message: "Missing \u2014 run dndev setup firebase" });
+        }
+        const framework = ctx.app?.framework ?? "vite";
+        const prefix = framework === "nextjs" ? "NEXT_PUBLIC_" : "VITE_";
+        const envPath = joinPath(ctx.appDir, ".env");
+        if (pathExists(envPath)) {
+          const content = readSync(envPath, { format: "text" });
+          if (typeof content === "string") {
+            const requiredKeys = ["FIREBASE_API_KEY", "FIREBASE_PROJECT_ID", "FIREBASE_AUTH_DOMAIN"];
+            const missing = requiredKeys.filter((key) => !content.includes(`${prefix}${key}=`));
+            if (missing.length === 0) {
+              results.push({ name: "Firebase .env", status: "pass", message: "All required keys present" });
+            } else {
+              results.push({ name: "Firebase .env", status: "fail", message: `Missing: ${missing.join(", ")}` });
+            }
+          }
+        } else {
+          results.push({ name: "Firebase .env", status: "fail", message: ".env file not found" });
+        }
+        const saKeyPaths = [
+          joinPath(ctx.appDir, "service-account-key.json"),
+          joinPath(ctx.projectRoot, "service-account-key.json")
+        ];
+        const saFound = saKeyPaths.some((p2) => pathExists(p2));
+        if (saFound) {
+          results.push({ name: "Service account key", status: "pass", message: "Found" });
+        } else {
+          results.push({ name: "Service account key", status: "warn", message: "Not found (needed for deploy/emu)" });
+        }
+        return results;
+      }
+    };
   }
-  const eslintArgs = fix ? ["--fix"] : [];
-  if (options.debug) {
-    eslintArgs.push("--debug");
+});
+
+// packages/tooling/src/cli/setup/supabase.ts
+function isValidSupabaseUrl(url) {
+  try {
+    const parsed = new URL(url);
+    return parsed.protocol === "https:" && (parsed.hostname.endsWith(".supabase.co") || parsed.hostname.endsWith(".supabase.in") || // Self-hosted or local
+    parsed.hostname === "localhost" || parsed.hostname === "127.0.0.1");
+  } catch {
+    return false;
   }
-  if (options.quiet) {
-    eslintArgs.push("--quiet");
+}
+function isValidPublicKey(key) {
+  return key.trim().length > 0;
+}
+var init_supabase = __esm({
+  "packages/tooling/src/cli/setup/supabase.ts"() {
+    "use strict";
+    init_utils();
   }
-  if (options.debug || options.verbose) {
-    log.debug(`Linting code${fix ? " and fixing issues" : ""}...`);
-    log.debug(`   Working directory: ${cwd}`);
-    log.debug(`   ESLint args: ${eslintArgs.join(" ")}`);
-  } else {
-    log.info(fix ? "Linting and fixing code..." : "Linting code...");
+});
+
+// packages/tooling/src/cli/doctor/check-supabase.ts
+var check_supabase_exports = {};
+__export(check_supabase_exports, {
+  supabaseCheck: () => supabaseCheck
+});
+import { spawnSync as spawnSync2 } from "node:child_process";
+var supabaseCheck;
+var init_check_supabase = __esm({
+  "packages/tooling/src/cli/doctor/check-supabase.ts"() {
+    "use strict";
+    init_utils();
+    init_pathResolver();
+    init_supabase();
+    supabaseCheck = {
+      id: "supabase",
+      name: "Supabase",
+      isRelevant(ctx) {
+        return pathExists(joinPath(ctx.appDir, "supabase")) || pathExists(joinPath(ctx.appDir, "supabase", "config.toml"));
+      },
+      async run(ctx) {
+        const results = [];
+        const framework = ctx.app?.framework === "nextjs" ? "nextjs" : "vite";
+        const prefix = framework === "nextjs" ? "NEXT_PUBLIC_" : "VITE_";
+        try {
+          const result = spawnSync2("supabase", ["--version"], {
+            stdio: "pipe",
+            encoding: "utf-8",
+            timeout: 1e4
+          });
+          if (result.status === 0) {
+            results.push({ name: "Supabase CLI", status: "pass", message: result.stdout.trim() });
+          } else {
+            results.push({ name: "Supabase CLI", status: "warn", message: "Not installed (needed for migrations)" });
+          }
+        } catch {
+          results.push({ name: "Supabase CLI", status: "warn", message: "Not installed" });
+        }
+        const configPath = joinPath(ctx.appDir, "supabase", "config.toml");
+        if (pathExists(configPath)) {
+          results.push({ name: "config.toml", status: "pass", message: "Found" });
+        } else {
+          results.push({ name: "config.toml", status: "warn", message: "Missing (expected at supabase/config.toml)" });
+        }
+        const envPath = joinPath(ctx.appDir, ".env");
+        if (pathExists(envPath)) {
+          const content = readSync(envPath, { format: "text" });
+          if (typeof content === "string") {
+            const urlMatch = content.match(new RegExp(`${prefix}SUPABASE_URL=(.+)`));
+            const url = urlMatch?.[1]?.trim();
+            if (url && isValidSupabaseUrl(url)) {
+              results.push({ name: "Supabase URL", status: "pass", message: url });
+            } else if (url) {
+              results.push({ name: "Supabase URL", status: "fail", message: "Invalid URL format" });
+            } else {
+              results.push({ name: "Supabase URL", status: "fail", message: "Missing in .env" });
+            }
+            const keyMatch = content.match(new RegExp(`${prefix}SUPABASE_(?:PUBLIC_KEY|ANON_KEY)=(.+)`));
+            const key = keyMatch?.[1]?.trim();
+            if (key && isValidPublicKey(key)) {
+              results.push({ name: "Supabase public key", status: "pass", message: "Present" });
+            } else {
+              results.push({ name: "Supabase public key", status: "fail", message: "Missing in .env" });
+            }
+          }
+        } else {
+          results.push({ name: "Supabase .env", status: "fail", message: ".env file not found" });
+        }
+        const functionsEnvCandidates = [
+          joinPath(ctx.appDir, "supabase", "functions", ".env"),
+          joinPath(ctx.appDir, "functions", ".env")
+        ];
+        let secretFound = false;
+        for (const fenvPath of functionsEnvCandidates) {
+          if (!pathExists(fenvPath)) continue;
+          const content = readSync(fenvPath, { format: "text" });
+          if (typeof content === "string" && content.match(/SUPABASE_(?:SECRET|SERVICE_ROLE)_KEY=.+/)) {
+            secretFound = true;
+            results.push({ name: "Secret key", status: "pass", message: `Found in ${fenvPath.split("/").pop()}` });
+            break;
+          }
+        }
+        if (!secretFound) {
+          results.push({ name: "Secret key", status: "warn", message: "Not found (needed for migrations + deploy)" });
+        }
+        return results;
+      }
+    };
   }
-  try {
-    const result = spawnSync("bunx", ["eslint", ".", ...eslintArgs], {
-      cwd,
-      stdio: "inherit",
-      env: process.env,
-      shell: true
-    });
-    const exitCode = result.status ?? 1;
-    if (exitCode === 0) {
-      if (!options.debug && !options.verbose) {
-        log.success("Linting completed successfully");
+});
+
+// packages/tooling/src/cli/doctor/check-stripe.ts
+var check_stripe_exports = {};
+__export(check_stripe_exports, {
+  stripeCheck: () => stripeCheck
+});
+function readEnvValue(envPath, varName) {
+  if (!pathExists(envPath)) return null;
+  const content = readSync(envPath, { format: "text" });
+  if (typeof content !== "string") return null;
+  for (const line of content.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    if (trimmed.startsWith(`${varName}=`)) {
+      let val = trimmed.substring(`${varName}=`.length).trim();
+      if (val.startsWith('"') && val.endsWith('"') || val.startsWith("'") && val.endsWith("'")) {
+        val = val.slice(1, -1);
+      }
+      return val || null;
+    }
+  }
+  return null;
+}
+function findFunctionsEnv(ctx) {
+  const candidates = [
+    joinPath(ctx.appDir, "supabase", "functions", ".env"),
+    joinPath(ctx.appDir, "functions", ".env")
+  ];
+  return candidates.find((p2) => pathExists(p2)) ?? null;
+}
+var stripeCheck;
+var init_check_stripe = __esm({
+  "packages/tooling/src/cli/doctor/check-stripe.ts"() {
+    "use strict";
+    init_utils();
+    init_pathResolver();
+    stripeCheck = {
+      id: "stripe",
+      name: "Stripe",
+      isRelevant(ctx) {
+        const pkgPath = joinPath(ctx.appDir, "package.json");
+        if (pathExists(pkgPath)) {
+          const pkg = readSync(pkgPath, { format: "json" });
+          if (pkg && typeof pkg === "object") {
+            const deps = pkg.dependencies;
+            if (deps?.["@donotdev/billing"]) return true;
+          }
+        }
+        const envPath = joinPath(ctx.appDir, ".env");
+        if (pathExists(envPath)) {
+          const content = readSync(envPath, { format: "text" });
+          if (typeof content === "string" && content.includes("STRIPE_PUBLISHABLE_KEY")) return true;
+        }
+        return false;
+      },
+      async run(ctx) {
+        const results = [];
+        const framework = ctx.app?.framework ?? "vite";
+        const prefix = framework === "nextjs" ? "NEXT_PUBLIC_" : "VITE_";
+        const envPath = joinPath(ctx.appDir, ".env");
+        const functionsEnvPath = findFunctionsEnv(ctx);
+        const pk = readEnvValue(envPath, `${prefix}STRIPE_PUBLISHABLE_KEY`);
+        let pkMode = null;
+        if (pk) {
+          if (pk.startsWith("pk_test_") || pk.startsWith("pk_live_")) {
+            pkMode = pk.startsWith("pk_test_") ? "test" : "live";
+            results.push({ name: "Publishable key", status: "pass", message: `Valid (${pkMode} mode)` });
+          } else {
+            results.push({ name: "Publishable key", status: "fail", message: "Invalid format \u2014 must start with pk_test_ or pk_live_" });
+          }
+        } else {
+          results.push({ name: "Publishable key", status: "fail", message: "Missing in .env" });
+        }
+        let skMode = null;
+        if (functionsEnvPath) {
+          const sk = readEnvValue(functionsEnvPath, "STRIPE_SECRET_KEY");
+          if (sk) {
+            if (sk.startsWith("sk_test_") || sk.startsWith("sk_live_") || sk.startsWith("rk_test_") || sk.startsWith("rk_live_")) {
+              skMode = sk.includes("_test_") ? "test" : "live";
+              results.push({ name: "Secret key", status: "pass", message: `Valid (${skMode} mode)` });
+            } else {
+              results.push({ name: "Secret key", status: "fail", message: "STRIPE_SECRET_KEY has invalid format" });
+            }
+          } else {
+            results.push({ name: "Secret key", status: "warn", message: "Not found in functions/.env" });
+          }
+        } else {
+          results.push({ name: "Secret key", status: "warn", message: "No functions/.env found" });
+        }
+        if (functionsEnvPath) {
+          const wh = readEnvValue(functionsEnvPath, "STRIPE_WEBHOOK_SECRET");
+          if (wh) {
+            if (wh.startsWith("whsec_")) {
+              results.push({ name: "Webhook secret", status: "pass", message: "Valid format" });
+            } else {
+              results.push({ name: "Webhook secret", status: "fail", message: "STRIPE_WEBHOOK_SECRET has invalid format" });
+            }
+          } else {
+            results.push({ name: "Webhook secret", status: "warn", message: "Not found \u2014 webhooks won't verify" });
+          }
+        }
+        if (pkMode && skMode) {
+          if (pkMode !== skMode) {
+            results.push({ name: "Key mode", status: "warn", message: `Publishable key is ${pkMode} but secret key is ${skMode}` });
+          } else {
+            results.push({ name: "Key mode", status: "pass", message: `Both keys are ${pkMode}` });
+          }
+        }
+        return results;
       }
-    } else {
-      if (!options.debug && !options.verbose) {
-        log.error("Linting found issues (see above for details)");
+    };
+  }
+});
+
+// packages/tooling/src/cli/doctor/check-auth.ts
+var check_auth_exports = {};
+__export(check_auth_exports, {
+  authCheck: () => authCheck
+});
+var authCheck;
+var init_check_auth = __esm({
+  "packages/tooling/src/cli/doctor/check-auth.ts"() {
+    "use strict";
+    init_utils();
+    init_pathResolver();
+    authCheck = {
+      id: "auth",
+      name: "Authentication",
+      isRelevant(ctx) {
+        const pkgPath = joinPath(ctx.appDir, "package.json");
+        if (pathExists(pkgPath)) {
+          const content = readSync(pkgPath, { format: "text" });
+          if (typeof content === "string" && content.includes("@donotdev/auth")) return true;
+        }
+        return false;
+      },
+      async run(ctx) {
+        const results = [];
+        results.push({ name: "@donotdev/auth", status: "pass", message: "Installed" });
+        const candidates = [
+          joinPath(ctx.appDir, "src", "providers.ts"),
+          joinPath(ctx.appDir, "src", "providers.tsx"),
+          joinPath(ctx.appDir, "src", "config", "providers.ts"),
+          joinPath(ctx.appDir, "src", "lib", "providers.ts")
+        ];
+        const providerFile = candidates.find((c) => pathExists(c));
+        if (providerFile) {
+          results.push({
+            name: "Providers config",
+            status: "pass",
+            message: `Found: ${providerFile.split("/").slice(-2).join("/")}`
+          });
+          const content = readSync(providerFile, { format: "text" });
+          if (typeof content === "string") {
+            const providers = [];
+            if (content.includes("email") || content.includes("Email")) providers.push("email");
+            if (content.includes("google") || content.includes("Google")) providers.push("google");
+            if (content.includes("github") || content.includes("GitHub")) providers.push("github");
+            if (content.includes("apple") || content.includes("Apple")) providers.push("apple");
+            if (providers.length > 0) {
+              results.push({
+                name: "Auth providers",
+                status: "pass",
+                message: `Configured: ${providers.join(", ")}`
+              });
+            }
+          }
+        } else {
+          results.push({ name: "Providers config", status: "warn", message: "No providers.ts found \u2014 auth may not work" });
+        }
+        const hasFirebase = pathExists(joinPath(ctx.projectRoot, ".firebaserc"));
+        const hasSupabase = pathExists(joinPath(ctx.appDir, "supabase"));
+        if (hasFirebase) {
+          results.push({
+            name: "Backend",
+            status: "pass",
+            message: "Firebase Auth (verify providers are enabled in console)",
+            detail: "Run dndev setup auth for setup coaching"
+          });
+        } else if (hasSupabase) {
+          results.push({
+            name: "Backend",
+            status: "pass",
+            message: "Supabase Auth (verify providers are enabled in dashboard)",
+            detail: "Run dndev setup auth for setup coaching"
+          });
+        } else {
+          results.push({ name: "Backend", status: "warn", message: "No backend detected for auth" });
+        }
+        return results;
+      }
+    };
+  }
+});
+
+// packages/tooling/src/cli/doctor/doctor.ts
+function renderResults(allResults, verbose) {
+  const lines = [];
+  for (const { checkName, results } of allResults) {
+    lines.push(checkName);
+    for (const result of results) {
+      const icon = STATUS_ICONS[result.status];
+      lines.push(`  ${icon} ${result.name}: ${result.message}`);
+      if (verbose && result.detail) {
+        lines.push(`     ${result.detail}`);
       }
     }
-    return exitCode;
-  } catch (err) {
-    throw DoNotDevError.from(
-      err,
-      "Failed to run ESLint",
-      "cli-execution-error"
-    );
+    lines.push("");
   }
+  Me(lines.join("\n"), "Health Check Results");
 }
+async function main(options = {}) {
+  Ie("DoNotDev Doctor");
+  const projectRoot = process.cwd();
+  let appDir = projectRoot;
+  let app = null;
+  const appsDir = joinPath(projectRoot, "apps");
+  if (pathExists(appsDir)) {
+    try {
+      app = await selectApp(projectRoot, options.app);
+      if (app) {
+        appDir = app.path;
+      }
+    } catch {
+    }
+  }
+  const ctx = {
+    projectRoot,
+    appDir,
+    app,
+    verbose: options.verbose
+  };
+  const allResults = [];
+  let hasFail = false;
+  const registry = options.check ? CHECK_REGISTRY.filter((e2) => e2.id === options.check) : CHECK_REGISTRY;
+  if (options.check && registry.length === 0) {
+    log.error(`Unknown check: ${options.check}. Available: ${CHECK_REGISTRY.map((e2) => e2.id).join(", ")}`);
+    Se("Doctor aborted.");
+    return 1;
+  }
+  for (const entry of registry) {
+    const check = await entry.load();
+    if (!check.isRelevant(ctx)) continue;
+    const results = await check.run(ctx);
+    allResults.push({ checkName: check.name, results });
+    if (results.some((r2) => r2.status === "fail")) {
+      hasFail = true;
+    }
+  }
+  if (allResults.length === 0) {
+    log.warn("No checks were relevant for this project.");
+    Se("Nothing to check.");
+    return 0;
+  }
+  renderResults(allResults, options.verbose ?? false);
+  let passes = 0;
+  let warnings = 0;
+  let fails = 0;
+  for (const { results } of allResults) {
+    for (const r2 of results) {
+      if (r2.status === "pass") passes++;
+      else if (r2.status === "warn") warnings++;
+      else if (r2.status === "fail") fails++;
+    }
+  }
+  const totalChecks = passes + warnings + fails;
+  const summaryParts = [`${passes}/${totalChecks} passed`];
+  if (warnings > 0) summaryParts.push(`${warnings} warning(s)`);
+  if (fails > 0) summaryParts.push(`${fails} failure(s)`);
+  const exitCode = hasFail ? 1 : 0;
+  Se(hasFail ? `Health check failed: ${summaryParts.join(", ")}` : `All clear: ${summaryParts.join(", ")}`);
+  return exitCode;
+}
+var CHECK_REGISTRY, STATUS_ICONS;
+var init_doctor = __esm({
+  "packages/tooling/src/cli/doctor/doctor.ts"() {
+    "use strict";
+    init_utils();
+    init_cli_output();
+    init_app_selector();
+    init_pathResolver();
+    CHECK_REGISTRY = [
+      { id: "env", load: async () => (await Promise.resolve().then(() => (init_check_env(), check_env_exports))).envCheck },
+      { id: "firebase", load: async () => (await Promise.resolve().then(() => (init_check_firebase(), check_firebase_exports))).firebaseCheck },
+      { id: "supabase", load: async () => (await Promise.resolve().then(() => (init_check_supabase(), check_supabase_exports))).supabaseCheck },
+      { id: "stripe", load: async () => (await Promise.resolve().then(() => (init_check_stripe(), check_stripe_exports))).stripeCheck },
+      { id: "auth", load: async () => (await Promise.resolve().then(() => (init_check_auth(), check_auth_exports))).authCheck }
+    ];
+    STATUS_ICONS = {
+      pass: "\u2705",
+      // green check
+      warn: "\u26A0\uFE0F",
+      // warning
+      fail: "\u274C"
+      // red x
+    };
+  }
+});
+
+// packages/cli/src/bin/commands/doctor.ts
+init_utils();
+
+// packages/tooling/src/index.ts
+init_utils();
+
+// packages/tooling/src/cli/index.ts
+init_utils();
+init_doctor();
 export {
   main
 };