varlock 0.0.6 → 0.0.8

package/dist/{chunk-DAZNZPLN.js → chunk-H5PNRKYP.js}

@@ -1,7 +1,16 @@
+import { detectJsPackageManager, logLines, fmt, pathExists, installJsDependency } from './chunk-GYHC6Y7D.js';
+import { define } from './chunk-33ROL4J5.js';
+import { loadVarlockEnvGraph } from './chunk-MPS3IXAW.js';
+import { StaticValueResolver, DotEnvFileDataSource, gracefulExit, checkIsFileGitIgnored, ansis_default } from './chunk-Y2RFMQ5X.js';
 import { __commonJS, __name, __toESM } from './chunk-XN24GZXQ.js';
-import y2, { stdin, stdout } from 'node:process';
-import O from 'node:readline';
-import { Writable } from 'node:stream';
+import path from 'path';
+import fs2 from 'fs/promises';
+import 'util';
+import y2, { stdin, stdout } from 'process';
+import O from 'readline';
+import { Writable } from 'stream';
+import { envSpecUpdater, ParsedEnvSpecStaticValue, parseEnvSpecDotEnvFile } from '@env-spec/parser';
+import { WriteStream } from 'tty';
 
 // ../../node_modules/.pnpm/sisteransi@1.0.5/node_modules/sisteransi/src/index.js
 var require_src = __commonJS({
@@ -132,7 +141,6 @@ var require_picocolors = __commonJS({
 
 // ../../node_modules/.pnpm/@clack+core@0.5.0/node_modules/@clack/core/dist/index.mjs
 var import_sisteransi = __toESM(require_src(), 1);
-var import_picocolors = __toESM(require_picocolors(), 1);
 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");
@@ -507,31 +515,6 @@ var SD = class extends x {
     this.value = u2 ? this.value.filter((t) => t !== this._value) : [...this.value, this._value];
   }
 };
-var TD = Object.defineProperty;
-var jD = /* @__PURE__ */ __name((e2, u2, t) => u2 in e2 ? TD(e2, u2, { enumerable: true, configurable: true, writable: true, value: t }) : e2[u2] = t, "jD");
-var U = /* @__PURE__ */ __name((e2, u2, t) => (jD(e2, typeof u2 != "symbol" ? u2 + "" : u2, t), t), "U");
-var MD = class extends x {
-  static {
-    __name(this, "MD");
-  }
-  constructor({ mask: u2, ...t }) {
-    super(t), U(this, "valueWithCursor", ""), U(this, "_mask", "\u2022"), this._mask = u2 ?? "\u2022", this.on("finalize", () => {
-      this.valueWithCursor = this.masked;
-    }), this.on("value", () => {
-      if (this.cursor >= this.value.length) this.valueWithCursor = `${this.masked}${import_picocolors.default.inverse(import_picocolors.default.hidden("_"))}`;
-      else {
-        const F2 = this.masked.slice(0, this.cursor), s = this.masked.slice(this.cursor);
-        this.valueWithCursor = `${F2}${import_picocolors.default.inverse(s[0])}${s.slice(1)}`;
-      }
-    });
-  }
-  get cursor() {
-    return this._cursor;
-  }
-  get masked() {
-    return this.value.replaceAll(/./g, this._mask);
-  }
-};
 var OD = Object.defineProperty;
 var PD = /* @__PURE__ */ __name((e2, u2, t) => u2 in e2 ? OD(e2, u2, { enumerable: true, configurable: true, writable: true, value: t }) : e2[u2] = t, "PD");
 var J = /* @__PURE__ */ __name((e2, u2, t) => (PD(e2, typeof u2 != "symbol" ? u2 + "" : u2, t), t), "J");
@@ -563,7 +546,7 @@ var LD = class extends x {
 };
 
 // ../../node_modules/.pnpm/@clack+prompts@0.11.0/node_modules/@clack/prompts/dist/index.mjs
-var import_picocolors2 = __toESM(require_picocolors(), 1);
+var import_picocolors = __toESM(require_picocolors(), 1);
 __toESM(require_src(), 1);
 function ce() {
   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";
@@ -583,7 +566,7 @@ var P2 = u("\u25CB", " ");
 u("\u25FB", "[\u2022]");
 u("\u25FC", "[+]");
 u("\u25FB", "[ ]");
-var $e = u("\u25AA", "\u2022");
+u("\u25AA", "\u2022");
 u("\u2500", "-");
 u("\u256E", "+");
 u("\u251C", "+");
@@ -596,80 +579,581 @@ var b2 = /* @__PURE__ */ __name((t) => {
   switch (t) {
     case "initial":
     case "active":
-      return import_picocolors2.default.cyan(le);
+      return import_picocolors.default.cyan(le);
     case "cancel":
-      return import_picocolors2.default.red(L2);
+      return import_picocolors.default.red(L2);
     case "error":
-      return import_picocolors2.default.yellow(W2);
+      return import_picocolors.default.yellow(W2);
     case "submit":
-      return import_picocolors2.default.green(C);
+      return import_picocolors.default.green(C);
   }
 }, "b");
 var G2 = /* @__PURE__ */ __name((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, v2, f) => {
-    const j2 = v2 === 0 && $2, E = v2 === f.length - 1 && g;
-    return j2 || E ? import_picocolors2.default.dim("...") : i(p2, v2 + l2 === n);
+  const $2 = a < r2.length && l2 > 0, g2 = 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 && g2;
+    return j2 || E ? import_picocolors.default.dim("...") : i(p2, v + l2 === n);
   });
 }, "G");
-var ge = /* @__PURE__ */ __name((t) => new MD({ validate: t.validate, mask: t.mask ?? $e, render() {
-  const n = `${import_picocolors2.default.gray(o)}
-${b2(this.state)}  ${t.message}
-`, r2 = this.valueWithCursor, i = this.masked;
-  switch (this.state) {
-    case "error":
-      return `${n.trim()}
-${import_picocolors2.default.yellow(o)}  ${i}
-${import_picocolors2.default.yellow(d2)}  ${import_picocolors2.default.yellow(this.error)}
-`;
-    case "submit":
-      return `${n}${import_picocolors2.default.gray(o)}  ${import_picocolors2.default.dim(i)}`;
-    case "cancel":
-      return `${n}${import_picocolors2.default.gray(o)}  ${import_picocolors2.default.strikethrough(import_picocolors2.default.dim(i ?? ""))}${i ? `
-${import_picocolors2.default.gray(o)}` : ""}`;
-    default:
-      return `${n}${import_picocolors2.default.cyan(o)}  ${r2}
-${import_picocolors2.default.cyan(d2)}
-`;
-  }
-} }).prompt(), "ge");
 var ve = /* @__PURE__ */ __name((t) => {
   const n = /* @__PURE__ */ __name((r2, i) => {
     const s = r2.label ?? String(r2.value);
     switch (i) {
       case "selected":
-        return `${import_picocolors2.default.dim(s)}`;
+        return `${import_picocolors.default.dim(s)}`;
       case "active":
-        return `${import_picocolors2.default.green(k2)} ${s} ${r2.hint ? import_picocolors2.default.dim(`(${r2.hint})`) : ""}`;
+        return `${import_picocolors.default.green(k2)} ${s} ${r2.hint ? import_picocolors.default.dim(`(${r2.hint})`) : ""}`;
       case "cancelled":
-        return `${import_picocolors2.default.strikethrough(import_picocolors2.default.dim(s))}`;
+        return `${import_picocolors.default.strikethrough(import_picocolors.default.dim(s))}`;
       default:
-        return `${import_picocolors2.default.dim(P2)} ${import_picocolors2.default.dim(s)}`;
+        return `${import_picocolors.default.dim(P2)} ${import_picocolors.default.dim(s)}`;
     }
   }, "n");
   return new LD({ options: t.options, initialValue: t.initialValue, render() {
-    const r2 = `${import_picocolors2.default.gray(o)}
+    const r2 = `${import_picocolors.default.gray(o)}
 ${b2(this.state)}  ${t.message}
 `;
     switch (this.state) {
       case "submit":
-        return `${r2}${import_picocolors2.default.gray(o)}  ${n(this.options[this.cursor], "selected")}`;
+        return `${r2}${import_picocolors.default.gray(o)}  ${n(this.options[this.cursor], "selected")}`;
       case "cancel":
-        return `${r2}${import_picocolors2.default.gray(o)}  ${n(this.options[this.cursor], "cancelled")}
-${import_picocolors2.default.gray(o)}`;
+        return `${r2}${import_picocolors.default.gray(o)}  ${n(this.options[this.cursor], "cancelled")}
+${import_picocolors.default.gray(o)}`;
       default:
-        return `${r2}${import_picocolors2.default.cyan(o)}  ${G2({ cursor: this.cursor, options: this.options, maxItems: t.maxItems, style: /* @__PURE__ */ __name((i, s) => n(i, s ? "active" : "inactive"), "style") }).join(`
-${import_picocolors2.default.cyan(o)}  `)}
-${import_picocolors2.default.cyan(d2)}
+        return `${r2}${import_picocolors.default.cyan(o)}  ${G2({ cursor: this.cursor, options: this.options, maxItems: t.maxItems, style: /* @__PURE__ */ __name((i, s) => n(i, s ? "active" : "inactive"), "style") }).join(`
+${import_picocolors.default.cyan(o)}  `)}
+${import_picocolors.default.cyan(d2)}
 `;
     }
   } }).prompt();
 }, "ve");
-`${import_picocolors2.default.gray(o)}  `;
+`${import_picocolors.default.gray(o)}  `;
+function isUnicodeSupported() {
+  const { env } = y2;
+  const { TERM, TERM_PROGRAM } = env;
+  if (y2.platform !== "win32") {
+    return TERM !== "linux";
+  }
+  return Boolean(env.WT_SESSION) || Boolean(env.TERMINUS_SUBLIME) || env.ConEmuTask === "{cmd::Cmder}" || TERM_PROGRAM === "Terminus-Sublime" || TERM_PROGRAM === "vscode" || TERM === "xterm-256color" || TERM === "alacritty" || TERM === "rxvt-unicode" || TERM === "rxvt-unicode-256color" || env.TERMINAL_EMULATOR === "JetBrains-JediTerm";
+}
+__name(isUnicodeSupported, "isUnicodeSupported");
+
+// src/cli/helpers/prompts.ts
+var unicode = isUnicodeSupported();
+var unicodeOr = /* @__PURE__ */ __name((c, fallback) => unicode ? c : fallback, "unicodeOr");
+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");
+unicodeOr("\u250C", "T");
+var S_BAR = unicodeOr("\u2502", "|");
+var S_BAR_END = unicodeOr("\u2514", "\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", "[ ]");
+unicodeOr("\u25AA", "\u2022");
+unicodeOr("\u2500", "-");
+unicodeOr("\u256E", "+");
+unicodeOr("\u251C", "+");
+unicodeOr("\u256F", "+");
+unicodeOr("\u25CF", "\u2022");
+unicodeOr("\u25C6", "*");
+unicodeOr("\u25B2", "!");
+unicodeOr("\u25A0", "x");
+var symbol = /* @__PURE__ */ __name((state) => {
+  switch (state) {
+    case "initial":
+    case "active":
+      return ansis_default.cyan(S_STEP_ACTIVE);
+    case "cancel":
+      return ansis_default.red(S_STEP_CANCEL);
+    case "error":
+      return ansis_default.yellow(S_STEP_ERROR);
+    case "submit":
+      return ansis_default.green(S_STEP_SUBMIT);
+  }
+}, "symbol");
+var limitOptions = /* @__PURE__ */ __name((params) => {
+  const { cursor, options, style } = params;
+  const output = params.output ?? process.stdout;
+  const rows = output instanceof WriteStream && output.rows !== void 0 ? output.rows : 10;
+  const paramMaxItems = params.maxItems ?? Number.POSITIVE_INFINITY;
+  const outputMaxItems = Math.max(rows - 4, 0);
+  const maxItems = Math.min(outputMaxItems, Math.max(paramMaxItems, 5));
+  let slidingWindowLocation = 0;
+  if (cursor >= slidingWindowLocation + maxItems - 3) {
+    slidingWindowLocation = Math.max(Math.min(cursor - maxItems + 3, options.length - maxItems), 0);
+  } else if (cursor < slidingWindowLocation + 2) {
+    slidingWindowLocation = Math.max(cursor - 2, 0);
+  }
+  const shouldRenderTopEllipsis = maxItems < options.length && slidingWindowLocation > 0;
+  const shouldRenderBottomEllipsis = maxItems < options.length && slidingWindowLocation + maxItems < options.length;
+  return options.slice(slidingWindowLocation, slidingWindowLocation + maxItems).map((option, i, arr) => {
+    const isTopLimit = i === 0 && shouldRenderTopEllipsis;
+    const isBottomLimit = i === arr.length - 1 && shouldRenderBottomEllipsis;
+    return isTopLimit || isBottomLimit ? ansis_default.dim("...") : style(option, i + slidingWindowLocation === cursor);
+  });
+}, "limitOptions");
+var confirm = /* @__PURE__ */ __name((opts) => {
+  const active = opts.active ?? "Yes";
+  const inactive = opts.inactive ?? "No";
+  return new dD({
+    active,
+    inactive,
+    input: opts.input,
+    output: opts.output,
+    initialValue: opts.initialValue ?? true,
+    render() {
+      const title = `
+${symbol(this.state)} ${opts.message}
+`;
+      const value = this.value ? active : inactive;
+      switch (this.state) {
+        case "submit":
+          return `${title}\u200E ${ansis_default.dim(value)}`;
+        case "cancel":
+          return `${title}\u200E ${ansis_default.strikethrough(
+            ansis_default.dim(value)
+          )}
+`;
+        default: {
+          return `${title}\u200E ${this.value ? `${ansis_default.green(S_RADIO_ACTIVE)} ${active}` : `${ansis_default.dim(S_RADIO_INACTIVE)} ${ansis_default.dim(active)}`} ${ansis_default.dim("/")} ${!this.value ? `${ansis_default.green(S_RADIO_ACTIVE)} ${inactive}` : `${ansis_default.dim(S_RADIO_INACTIVE)} ${ansis_default.dim(inactive)}`}
+`;
+        }
+      }
+    }
+  }).prompt();
+}, "confirm");
+var select = /* @__PURE__ */ __name((opts) => {
+  const opt = /* @__PURE__ */ __name((option, state) => {
+    const label = option.label ?? String(option.value);
+    switch (state) {
+      case "selected":
+        return `${ansis_default.dim(label)}`;
+      case "active":
+        return `${ansis_default.green(S_RADIO_ACTIVE)} ${label} ${option.hint ? ansis_default.dim(`(${option.hint})`) : ""}`;
+      case "cancelled":
+        return `${ansis_default.strikethrough(ansis_default.dim(label))}`;
+      default:
+        return `${ansis_default.dim(S_RADIO_INACTIVE)} ${ansis_default.dim(label)}`;
+    }
+  }, "opt");
+  return new LD({
+    options: opts.options,
+    input: opts.input,
+    output: opts.output,
+    initialValue: opts.initialValue,
+    render() {
+      const title = `${ansis_default.gray(S_BAR)}
+${symbol(this.state)}  ${opts.message}
+`;
+      switch (this.state) {
+        case "submit":
+          return `${title}${ansis_default.gray(S_BAR)}  ${opt(this.options[this.cursor], "selected")}`;
+        case "cancel":
+          return `${title}${ansis_default.gray(S_BAR)}  ${opt(
+            this.options[this.cursor],
+            "cancelled"
+          )}
+${ansis_default.gray(S_BAR)}`;
+        default: {
+          return `${title}${ansis_default.cyan(S_BAR)}  ${limitOptions({
+            output: opts.output,
+            cursor: this.cursor,
+            options: this.options,
+            maxItems: opts.maxItems,
+            style: /* @__PURE__ */ __name((item, active) => opt(item, active ? "active" : "inactive"), "style")
+          }).join(`
+${ansis_default.cyan(S_BAR)}  `)}
+${ansis_default.cyan(S_BAR_END)}
+`;
+        }
+      }
+    }
+  }).prompt();
+}, "select");
+var multiselect = /* @__PURE__ */ __name((opts) => {
+  const opt = /* @__PURE__ */ __name((option, state) => {
+    const label = option.label ?? String(option.value);
+    if (state === "active") {
+      return `${ansis_default.cyan(S_CHECKBOX_ACTIVE)} ${label} ${option.hint ? ansis_default.dim(`(${option.hint})`) : ""}`;
+    }
+    if (state === "selected") {
+      return `${ansis_default.green(S_CHECKBOX_SELECTED)} ${ansis_default.dim(label)} ${option.hint ? ansis_default.dim(`(${option.hint})`) : ""}`;
+    }
+    if (state === "cancelled") {
+      return `${ansis_default.strikethrough(ansis_default.dim(label))}`;
+    }
+    if (state === "active-selected") {
+      return `${ansis_default.green(S_CHECKBOX_SELECTED)} ${label} ${option.hint ? ansis_default.dim(`(${option.hint})`) : ""}`;
+    }
+    if (state === "submitted") {
+      return `${ansis_default.dim(label)}`;
+    }
+    return `${ansis_default.dim(S_CHECKBOX_INACTIVE)} ${ansis_default.dim(label)}`;
+  }, "opt");
+  return new SD({
+    options: opts.options,
+    input: opts.input,
+    output: opts.output,
+    initialValues: opts.initialValues,
+    required: opts.required ?? true,
+    cursorAt: opts.cursorAt,
+    validate(selected) {
+      if (this.required && selected.length === 0) {
+        return `Please select at least one option.
+${ansis_default.reset(
+          ansis_default.dim(
+            `Press ${ansis_default.gray(ansis_default.bgWhite(ansis_default.inverse(" space ")))} to select, ${ansis_default.gray(
+              ansis_default.bgWhite(ansis_default.inverse(" enter "))
+            )} to submit`
+          )
+        )}`;
+      }
+    },
+    render() {
+      let title = `${ansis_default.gray(S_BAR)}
+${symbol(this.state)}  ${opts.message}
+`;
+      if (opts.details) title += `${ansis_default.gray(S_BAR)} ${opts.details}
+`;
+      const styleOption = /* @__PURE__ */ __name((option, active) => {
+        const selected = this.value.includes(option.value);
+        if (active && selected) {
+          return opt(option, "active-selected");
+        }
+        if (selected) {
+          return opt(option, "selected");
+        }
+        return opt(option, active ? "active" : "inactive");
+      }, "styleOption");
+      switch (this.state) {
+        case "submit": {
+          return `${title}${ansis_default.gray(S_BAR)}  ${this.options.filter(({ value }) => this.value.includes(value)).map((option) => opt(option, "submitted")).join(ansis_default.dim(", ")) || ansis_default.dim("none")}`;
+        }
+        case "cancel": {
+          const label = this.options.filter(({ value }) => this.value.includes(value)).map((option) => opt(option, "cancelled")).join(ansis_default.dim(", "));
+          return `${title}${ansis_default.gray(S_BAR)}  ${label.trim() ? `${label}
+${ansis_default.gray(S_BAR)}` : ""}`;
+        }
+        case "error": {
+          const footer = this.error.split("\n").map((ln, i) => i === 0 ? `${ansis_default.yellow(S_BAR_END)}  ${ansis_default.yellow(ln)}` : `   ${ln}`).join("\n");
+          return `${title + ansis_default.yellow(S_BAR)}  ${limitOptions({
+            output: opts.output,
+            options: this.options,
+            cursor: this.cursor,
+            maxItems: opts.maxItems,
+            style: styleOption
+          }).join(`
+${ansis_default.yellow(S_BAR)}  `)}
+${footer}
+`;
+        }
+        default: {
+          return `${title}${ansis_default.cyan(S_BAR)}  ${limitOptions({
+            output: opts.output,
+            options: this.options,
+            cursor: this.cursor,
+            maxItems: opts.maxItems,
+            style: styleOption
+          }).join(`
+${ansis_default.cyan(S_BAR)}  `)}
+${ansis_default.cyan(S_BAR_END)}
+`;
+        }
+      }
+    }
+  }).prompt();
+}, "multiselect");
+var prompts = {
+  confirm,
+  select,
+  multiselect
+};
+var prompts_default = prompts;
+var PUBLIC_PREFIXES = [
+  "PUBLIC",
+  "VITE",
+  "NEXT_PUBLIC",
+  "NUXT_PUBLIC"
+];
+var PUBLIC_KEYWORDS = ["PUBLIC"];
+var SENSITIVE_KEYWORDS = [
+  "SECRET",
+  "API_KEY",
+  "PASSWORD",
+  "TOKEN",
+  "PRIVATE",
+  "CREDENTIALS"
+];
+function isValidUrl(val) {
+  try {
+    const u2 = new URL(val);
+    return true;
+  } catch (err) {
+    return false;
+  }
+}
+__name(isValidUrl, "isValidUrl");
+var EMAIL_REGEX = /^(([^<>()[\]\\.,;:\s@"]+(\.[^<>()[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/;
+var VALID_NUMBER_REGEX = /^(0|([1-9][0-9]*))?(\.[0-9]+)?$/;
+function inferItemDecorators(file, itemKey, valueStr) {
+  let itemIsPublic = false;
+  if (PUBLIC_PREFIXES.some((prefix) => itemKey.startsWith(prefix))) itemIsPublic = true;
+  if (PUBLIC_KEYWORDS.some((keyword) => itemKey.includes(keyword))) itemIsPublic = true;
+  let itemIsSensitive = false;
+  if (SENSITIVE_KEYWORDS.some((keyword) => itemKey.includes(keyword))) itemIsSensitive = true;
+  if (itemIsPublic) ; else if (itemIsSensitive) {
+    envSpecUpdater.setItemDecorator(file, itemKey, "sensitive", "true");
+  }
+  if (itemKey === "PORT" || itemKey.endsWith("_PORT")) {
+    envSpecUpdater.setItemDecorator(file, itemKey, "type", "port");
+  } else if (itemKey.endsWith("_EMAIL")) {
+    envSpecUpdater.setItemDecorator(file, itemKey, "type", "email");
+  } else if (itemKey.endsWith("_URL") || itemKey.endsWith("_URI")) {
+    envSpecUpdater.setItemDecorator(file, itemKey, "type", "url");
+  } else if (valueStr) {
+    if (valueStr.startsWith("<") && valueStr.endsWith(">")) {
+      envSpecUpdater.setItemDecorator(file, itemKey, "example", valueStr);
+    }
+    if (valueStr === "true" || valueStr === "false") {
+      envSpecUpdater.setItemDecorator(file, itemKey, "type", "boolean");
+    } else if (EMAIL_REGEX.test(valueStr)) {
+      envSpecUpdater.setItemDecorator(file, itemKey, "type", "email");
+    } else if (valueStr !== "0" && valueStr !== "1" && VALID_NUMBER_REGEX.test(valueStr)) {
+      envSpecUpdater.setItemDecorator(file, itemKey, "type", "number");
+    } else if (isValidUrl(valueStr)) {
+      envSpecUpdater.setItemDecorator(file, itemKey, "type", "url");
+    }
+  }
+}
+__name(inferItemDecorators, "inferItemDecorators");
+function inferSchemaUpdates(file) {
+  for (const item of file.configItems) {
+    const valueStr = item.value instanceof ParsedEnvSpecStaticValue && item.value.value?.toString() || "";
+    inferItemDecorators(file, item.key, valueStr);
+  }
+}
+__name(inferSchemaUpdates, "inferSchemaUpdates");
+function ensureAllItemsExist(envGraph, schemaFile) {
+  const addedItemKeys = [];
+  for (const itemKey in envGraph.configSchema) {
+    const item = envGraph.configSchema[itemKey];
+    const itemInSchema = schemaFile.configItems.find((i) => i.key === itemKey);
+    if (!itemInSchema) {
+      if (addedItemKeys.length === 0) {
+        envSpecUpdater.injectFromStr(schemaFile, [
+          "",
+          "# items added to schema by `varlock init`",
+          "# that were missing in example, but detected in other env files",
+          "# PLEASE REVIEW THESE!",
+          "# ---",
+          ""
+        ].join("\n"), { location: "end" });
+      }
+      addedItemKeys.push(itemKey);
+      envSpecUpdater.injectFromStr(schemaFile, [`${itemKey}=`].join("\n"));
+      const itemValue = item.valueResolver instanceof StaticValueResolver && item.valueResolver.staticValue || "";
+      inferItemDecorators(schemaFile, itemKey, String(itemValue));
+    }
+  }
+}
+__name(ensureAllItemsExist, "ensureAllItemsExist");
+async function detectRedundantValues(envGraph, opts = {}) {
+  const schema = envGraph.schemaDataSource;
+  if (!schema) return {};
+  const redundantItemsBySourcePath = {};
+  const schemaValues = schema.getStaticValues();
+  for (const source of envGraph.dataSources) {
+    if (source === schema) continue;
+    if (source.type === "example") continue;
+    if (!(source instanceof DotEnvFileDataSource) || !source.parsedFile) continue;
+    const sourceValues = source.getStaticValues();
+    for (const [key, value] of Object.entries(sourceValues)) {
+      if (schemaValues[key] !== value) continue;
+      redundantItemsBySourcePath[source.fullPath] ||= [];
+      redundantItemsBySourcePath[source.fullPath].push(key);
+      if (opts.delete) {
+        envSpecUpdater.deleteItem(source.parsedFile, key);
+      }
+    }
+    if (opts.delete) {
+      await fs2.writeFile(source.fullPath, source.parsedFile.toString(), "utf8");
+    }
+  }
+  return redundantItemsBySourcePath;
+}
+__name(detectRedundantValues, "detectRedundantValues");
+
+// src/cli/commands/init.command.ts
+var commandSpec = define({
+  name: "init",
+  description: "Set up varlock in the current project",
+  args: {}
+});
+var commandFn = /* @__PURE__ */ __name(async (ctx) => {
+  const jsPackageManager = detectJsPackageManager();
+  console.log("\u{1F9D9} Hello and welcome to Varlock \u{1F512}\u{1F525}\u2728");
+  let envGraph = await loadVarlockEnvGraph();
+  const existingSchemaFile = envGraph.dataSources.find((dataSource) => {
+    return dataSource.type === "schema";
+  });
+  if (existingSchemaFile) {
+    logLines([
+      `It looks like you already have a ${fmt.fileName(".env.schema")} file \u{1F389}`,
+      "This init helper is meant to help you get a new project set up.",
+      "If you need to make changes to your schema or values, you can update your files directly.",
+      "See more docs at https://varlock.dev/guides/schema"
+    ]);
+  } else {
+    let exampleFileToConvert = null;
+    const allExampleFiles = envGraph.dataSources.filter((dataSource) => {
+      return dataSource instanceof DotEnvFileDataSource && dataSource.type === "example";
+    });
+    if (allExampleFiles.length === 1) {
+      exampleFileToConvert = allExampleFiles[0];
+    } else if (allExampleFiles.length > 1) {
+      console.log("");
+      const selectedExample = await ve({
+        message: `We detected more than one example .env file. Which one should we use to create your new ${fmt.fileName(".env.schema")}?`,
+        options: allExampleFiles.map((file) => ({
+          label: file.fileName,
+          value: file
+        }))
+      });
+      if (pD(selectedExample)) return gracefulExit(0);
+      exampleFileToConvert = selectedExample;
+    }
+    const parsedEnvFile = exampleFileToConvert?.parsedFile || parseEnvSpecDotEnvFile("");
+    if (!parsedEnvFile) throw new Error("No parsed .env file found");
+    envSpecUpdater.ensureHeader(parsedEnvFile, [
+      "This env file uses @env-spec - see https://varlock.dev/env-spec for more info",
+      ""
+      // TODO: add env spec version? real links?
+    ].join("\n"));
+    envSpecUpdater.setRootDecorator(parsedEnvFile, "defaultRequired", "false", { explicitTrue: true });
+    envSpecUpdater.setRootDecorator(parsedEnvFile, "defaultSensitive", "false", { explicitTrue: true });
+    envSpecUpdater.setRootDecorator(parsedEnvFile, "generateTypes", "lang=ts, path=env.d.ts", { bareFnArgs: true });
+    envSpecUpdater.injectFromStr(parsedEnvFile, [
+      "",
+      "# example env variable injected by `varlock init` \u26A0\uFE0F DELETE THIS ITEM! \u26A0\uFE0F",
+      '# @required @sensitive @example="example value"',
+      'EXAMPLE_ITEM="delete me!"',
+      ""
+    ].join("\n"), { location: "after_header" });
+    inferSchemaUpdates(parsedEnvFile);
+    ensureAllItemsExist(envGraph, parsedEnvFile);
+    const schemaFilePath = path.join(process.cwd(), ".env.schema");
+    await fs2.writeFile(schemaFilePath, parsedEnvFile.toString());
+    if (exampleFileToConvert) {
+      logLines([
+        "",
+        `Your ${fmt.fileName(exampleFileToConvert.fileName)} has been used to generate your new ${fmt.fileName(".env.schema")}:`,
+        fmt.filePath(schemaFilePath)
+      ]);
+    } else {
+      logLines([
+        "",
+        `Your new ${fmt.fileName(".env.schema")} file has been created:`,
+        fmt.filePath(schemaFilePath)
+      ]);
+    }
+    if (await checkIsFileGitIgnored(schemaFilePath)) {
+      logLines([ansis_default.dim(`(and updated ${fmt.fileName(".gitignore")} to ensure it will be tracked by git)`)]);
+      await fs2.appendFile(".gitignore", "\n!.env.schema");
+    }
+    logLines([
+      "",
+      ansis_default.bold(`\u{1F6A7} Please review and update your new ${fmt.fileName(".env.schema")} file! \u{1F6A7}`),
+      `We've done our best to get you started, but you must review and make sure it is correct!`,
+      "",
+      `\u{1F449} Some helpful pointers to get you started:`,
+      `- add a description to each item when the name is not self explanitory - it will come through in generated types`,
+      `- use ${fmt.decorator("@required")} (or ${fmt.decorator("@optional")}) to tag items that should fail validation when empty`,
+      `- use ${fmt.decorator("@sensitive")} to tag items that contain sensitive secrets, and must be handled accordingly`,
+      `- use ${fmt.decorator("@type")} to set an item's data type (if not a basic string), which affects validation and coercion logic`,
+      `- if an item value is a ${ansis_default.italic("useful example")} rather than a default, use ${fmt.decorator("@example")}`,
+      `- if an item value is just a dummy placeholder, delete it`
+    ]);
+    const confirmReviewed = await prompts_default.confirm({
+      message: `Have you reviewed and updated your new ${fmt.fileName(".env.schema")} file?`
+    });
+    if (pD(confirmReviewed)) return gracefulExit(0);
+    envGraph = await loadVarlockEnvGraph();
+    if (envGraph.configSchema.EXAMPLE_ITEM) {
+      logLines([
+        "",
+        ansis_default.bold(`\u{1F6A8} Really? ${ansis_default.red("You didn't remove the EXAMPLE_ITEM!")}`),
+        `Please make sure your schema is all correct before using it...`
+      ]);
+    }
+    if (exampleFileToConvert) {
+      const confirmDeleteExample = await prompts_default.confirm({
+        message: `Should we delete your ${fmt.fileName(exampleFileToConvert.fileName)} file? ${ansis_default.italic.gray("(you can always do this yourself later)")}`
+      });
+      if (pD(confirmDeleteExample)) return gracefulExit(0);
+      if (confirmDeleteExample) {
+        await fs2.unlink(exampleFileToConvert.fullPath);
+      }
+    }
+    const defaultsFile = envGraph.dataSources.find((dataSource) => {
+      return dataSource instanceof DotEnvFileDataSource && dataSource.type === "defaults";
+    });
+    if (defaultsFile) {
+      logLines([
+        "",
+        `\u{1F6A7} We detected a ${fmt.fileName(defaultsFile.fileName)} file in your project`,
+        `You should migrate these default values into ${fmt.fileName(".env.schema")} and delete ${fmt.fileName(defaultsFile.fileName)}`
+      ]);
+    }
+    const redundantInfo = await detectRedundantValues(envGraph);
+    if (Object.keys(redundantInfo).length > 0) {
+      logLines([
+        "",
+        ansis_default.bold("\u203C\uFE0F  Now that your schema contains defaults, some values in your other .env files are redundant:")
+      ]);
+      for (const [sourcePath, itemKeys] of Object.entries(redundantInfo)) {
+        console.log(fmt.filePath(sourcePath));
+        console.log("  ", itemKeys.map((k3) => ansis_default.italic(k3)).join(", "));
+      }
+      const confirmDeleteRedundant = await prompts_default.confirm({
+        message: "Should we delete these redundant values from your other .env files?"
+      });
+      if (pD(confirmDeleteRedundant)) return gracefulExit(0);
+      if (confirmDeleteRedundant) {
+        await detectRedundantValues(envGraph, { delete: true });
+      }
+    }
+    logLines([
+      "",
+      ansis_default.bold("\u{1F389} Great!"),
+      `You can run ${fmt.command("varlock load", { jsPackageManager })} to attempt loading your env vars validate against your new schema.`,
+      "",
+      "Check out our docs for more info about integrating into your application.",
+      "",
+      "\u{1F4D6} https://varlock.dev \u{1F448}",
+      ""
+    ]);
+  }
+  if (jsPackageManager && await pathExists(path.join(process.cwd(), "package.json"))) {
+    const installResult = installJsDependency({
+      packageManager: jsPackageManager.name,
+      packageName: "varlock"
+    });
+    if (installResult) {
+      logLines([
+        "",
+        `\u2705 Added ${fmt.packageName("varlock")} as a dependency in your package.json`
+      ]);
+    }
+  }
+}, "commandFn");
 
-export { LD, SD, dD, ge, pD, ve };
-//# sourceMappingURL=chunk-DAZNZPLN.js.map
-//# sourceMappingURL=chunk-DAZNZPLN.js.map
+export { commandFn, commandSpec };
+//# sourceMappingURL=chunk-H5PNRKYP.js.map
+//# sourceMappingURL=chunk-H5PNRKYP.js.map