varlock 0.0.0 → 0.0.2

package/dist/chunk-RY3YIJFG.js

@@ -0,0 +1,681 @@
+import { ve, pD, dD, SD, LD } from './chunk-DAZNZPLN.js';
+import { logLines, fmt } from './chunk-LQZ6ICSS.js';
+import { define } from './chunk-33ROL4J5.js';
+import { joinAndCompact, loadVarlockEnvGraph } from './chunk-6YLXKXKR.js';
+import { my_dash_default, StaticValueResolver, DotEnvFileDataSource, checkIsFileGitIgnored } from './chunk-G4BD2BPH.js';
+import { ansis_default } from './chunk-7UQXFWKN.js';
+import { __name } from './chunk-XN24GZXQ.js';
+import path from 'node:path';
+import fs3, { access } from 'node:fs/promises';
+import { envSpecUpdater, ParsedEnvSpecStaticValue, parseEnvSpecDotEnvFile } from '@env-spec/parser';
+import fs2, { accessSync, existsSync } from 'node:fs';
+import { WriteStream } from 'node:tty';
+import process2 from 'node:process';
+import { execSync } from 'node:child_process';
+
+async function pathExists(p) {
+  try {
+    await access(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+__name(pathExists, "pathExists");
+function pathExistsSync(p) {
+  try {
+    accessSync(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+__name(pathExistsSync, "pathExistsSync");
+function isUnicodeSupported() {
+  const { env } = process2;
+  const { TERM, TERM_PROGRAM } = env;
+  if (process2.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 u = 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 fs3.writeFile(source.fullPath, source.parsedFile.toString(), "utf8");
+    }
+  }
+  return redundantItemsBySourcePath;
+}
+__name(detectRedundantValues, "detectRedundantValues");
+
+// src/cli/helpers/exit-error.ts
+var CliExitError = class extends Error {
+  constructor(message, more) {
+    super(message);
+    this.more = more;
+  }
+  static {
+    __name(this, "CliExitError");
+  }
+  get forceExit() {
+    return !!this.more?.forceExit;
+  }
+  getFormattedOutput() {
+    let msg = `
+\u{1F4A5} ${ansis_default.red(this.message)} \u{1F4A5}
+`;
+    if (this.more?.details) {
+      msg += joinAndCompact(my_dash_default.castArray(this.more?.details), "\n");
+    }
+    if (this.more?.suggestion) {
+      msg += joinAndCompact(my_dash_default.castArray(this.more?.suggestion), "\n");
+    }
+    msg += "\n";
+    return msg;
+  }
+};
+var JS_PACKAGE_MANAGERS = Object.freeze({
+  npm: {
+    name: "npm",
+    lockfile: "package-lock.json",
+    add: "npm install",
+    // add also works
+    exec: "npm exec --",
+    dlx: "npx"
+  },
+  pnpm: {
+    name: "pnpm",
+    lockfile: "pnpm-lock.yaml",
+    add: "pnpm add",
+    exec: "pnpm exec",
+    dlx: "pnpm dlx"
+  },
+  yarn: {
+    name: "yarn",
+    lockfile: "yarn.lock",
+    add: "yarn add",
+    exec: "yarn exec --",
+    dlx: "yarn dlx"
+  },
+  bun: {
+    name: "bun",
+    lockfile: "bun.lockb",
+    add: "bun add",
+    exec: "bun run",
+    dlx: "bunx"
+  },
+  deno: {
+    //! deno not fully supported yet
+    name: "deno",
+    lockfile: "deno.lock",
+    add: "deno add",
+    // TODO: don't think these are quite right...
+    exec: "deno run",
+    dlx: "deno run"
+  }
+});
+function detectJsPackageManager(opts) {
+  let cwd = opts?.cwd || process.cwd();
+  const cwdParts = cwd.split(path.sep);
+  do {
+    let pm;
+    let detectedPm;
+    for (pm in JS_PACKAGE_MANAGERS) {
+      const lockFilePath = path.join(
+        cwd,
+        JS_PACKAGE_MANAGERS[pm].lockfile
+      );
+      if (pathExistsSync(lockFilePath)) {
+        if (detectedPm) {
+          throw new CliExitError("Found multiple js package manager lockfiles", {
+            details: `${JS_PACKAGE_MANAGERS[pm].lockfile} and ${JS_PACKAGE_MANAGERS[detectedPm].lockfile}`,
+            forceExit: true
+          });
+        }
+        detectedPm = pm;
+      }
+    }
+    if (detectedPm) return JS_PACKAGE_MANAGERS[detectedPm];
+    cwdParts.pop();
+    cwd = path.join(...cwdParts);
+    if (opts?.workspaceRootPath) {
+      if (opts.workspaceRootPath === cwd) break;
+    } else {
+      if (pathExistsSync(path.join(cwd, ".git"))) break;
+    }
+  } while (cwd);
+  if (process.env.npm_config_user_agent) {
+    const pmFromAgent = process.env.npm_config_user_agent.split("/")[0];
+    if (Object.keys(JS_PACKAGE_MANAGERS).includes(pmFromAgent)) {
+      return JS_PACKAGE_MANAGERS[pmFromAgent];
+    }
+  }
+  if (opts?.exitIfNotFound) {
+    throw new CliExitError("Unable to find detect your JavaScript package manager!", {
+      suggestion: "We look for lock files (ex: package-lock.json) so you may just need to run a dependency install (ie `npm install`)",
+      forceExit: true
+    });
+  }
+}
+__name(detectJsPackageManager, "detectJsPackageManager");
+function installJsDependency(opts) {
+  const packageJsonPath = path.join(opts.packagePath || process.cwd(), "package.json");
+  if (!existsSync(packageJsonPath)) return false;
+  const packageJson = JSON.parse(fs2.readFileSync(packageJsonPath, "utf8"));
+  if (packageJson.dependencies?.varlock) return false;
+  execSync([
+    opts.packagePath ? `cd ${opts.packagePath} &&` : "",
+    // `add` works in all of them
+    `${opts.packageManager} add ${opts.packageName}`,
+    opts.isMonoRepoRoot && opts.packageManager === "pnpm" ? "-w" : ""
+  ].join(" "));
+  return true;
+}
+__name(installJsDependency, "installJsDependency");
+
+// 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) => {
+  {
+    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)) process.exit(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`",
+      '# @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 fs3.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 fs3.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:`,
+      `- 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 purely an ${ansis_default.italic("example")} rather than a default, move it into an ${fmt.decorator("@example")} decorator, or delete it`,
+      `- 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)) process.exit(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)) process.exit(0);
+      if (confirmDeleteExample) {
+        await fs3.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((k) => ansis_default.italic(k)).join(", "));
+      }
+      const confirmDeleteRedundant = await prompts_default.confirm({
+        message: "Should we delete these redundant values from your other .env files?"
+      });
+      if (pD(confirmDeleteRedundant)) process.exit(0);
+      if (confirmDeleteRedundant) {
+        await detectRedundantValues(envGraph, { delete: true });
+      }
+    }
+    logLines([
+      "",
+      ansis_default.bold("\u{1F389} Great!"),
+      `You can run ${fmt.command("varlock load")} to attempt loading your env vars validate against your new schema.`,
+      "Check out our integration guide for more info about integrating into your application."
+    ]);
+  }
+  const jsPackageManager = detectJsPackageManager();
+  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 { CliExitError, commandFn, commandSpec };
+//# sourceMappingURL=chunk-RY3YIJFG.js.map
+//# sourceMappingURL=chunk-RY3YIJFG.js.map