@xlameiro/env-typegen 0.1.0

package/dist/cli.js

@@ -0,0 +1,768 @@
+#!/usr/bin/env node
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// ../../node_modules/.pnpm/picocolors@1.1.1/node_modules/picocolors/picocolors.js
+var require_picocolors = __commonJS({
+  "../../node_modules/.pnpm/picocolors@1.1.1/node_modules/picocolors/picocolors.js"(exports, module) {
+    "use strict";
+    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 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;
+    };
+    var replaceClose = (string, close, replace, index) => {
+      let result = "", cursor = 0;
+      do {
+        result += string.substring(cursor, index) + replace;
+        cursor = index + close.length;
+        index = string.indexOf(close, cursor);
+      } while (~index);
+      return result + string.substring(cursor);
+    };
+    var createColors = (enabled = isColorSupported) => {
+      let f = enabled ? formatter : () => String;
+      return {
+        isColorSupported: enabled,
+        reset: f("\x1B[0m", "\x1B[0m"),
+        bold: f("\x1B[1m", "\x1B[22m", "\x1B[22m\x1B[1m"),
+        dim: f("\x1B[2m", "\x1B[22m", "\x1B[22m\x1B[2m"),
+        italic: f("\x1B[3m", "\x1B[23m"),
+        underline: f("\x1B[4m", "\x1B[24m"),
+        inverse: f("\x1B[7m", "\x1B[27m"),
+        hidden: f("\x1B[8m", "\x1B[28m"),
+        strikethrough: f("\x1B[9m", "\x1B[29m"),
+        black: f("\x1B[30m", "\x1B[39m"),
+        red: f("\x1B[31m", "\x1B[39m"),
+        green: f("\x1B[32m", "\x1B[39m"),
+        yellow: f("\x1B[33m", "\x1B[39m"),
+        blue: f("\x1B[34m", "\x1B[39m"),
+        magenta: f("\x1B[35m", "\x1B[39m"),
+        cyan: f("\x1B[36m", "\x1B[39m"),
+        white: f("\x1B[37m", "\x1B[39m"),
+        gray: f("\x1B[90m", "\x1B[39m"),
+        bgBlack: f("\x1B[40m", "\x1B[49m"),
+        bgRed: f("\x1B[41m", "\x1B[49m"),
+        bgGreen: f("\x1B[42m", "\x1B[49m"),
+        bgYellow: f("\x1B[43m", "\x1B[49m"),
+        bgBlue: f("\x1B[44m", "\x1B[49m"),
+        bgMagenta: f("\x1B[45m", "\x1B[49m"),
+        bgCyan: f("\x1B[46m", "\x1B[49m"),
+        bgWhite: f("\x1B[47m", "\x1B[49m"),
+        blackBright: f("\x1B[90m", "\x1B[39m"),
+        redBright: f("\x1B[91m", "\x1B[39m"),
+        greenBright: f("\x1B[92m", "\x1B[39m"),
+        yellowBright: f("\x1B[93m", "\x1B[39m"),
+        blueBright: f("\x1B[94m", "\x1B[39m"),
+        magentaBright: f("\x1B[95m", "\x1B[39m"),
+        cyanBright: f("\x1B[96m", "\x1B[39m"),
+        whiteBright: f("\x1B[97m", "\x1B[39m"),
+        bgBlackBright: f("\x1B[100m", "\x1B[49m"),
+        bgRedBright: f("\x1B[101m", "\x1B[49m"),
+        bgGreenBright: f("\x1B[102m", "\x1B[49m"),
+        bgYellowBright: f("\x1B[103m", "\x1B[49m"),
+        bgBlueBright: f("\x1B[104m", "\x1B[49m"),
+        bgMagentaBright: f("\x1B[105m", "\x1B[49m"),
+        bgCyanBright: f("\x1B[106m", "\x1B[49m"),
+        bgWhiteBright: f("\x1B[107m", "\x1B[49m")
+      };
+    };
+    module.exports = createColors();
+    module.exports.createColors = createColors;
+  }
+});
+
+// src/cli.ts
+import path6 from "path";
+import { fileURLToPath, pathToFileURL as pathToFileURL2 } from "url";
+import { inspect, parseArgs } from "util";
+
+// src/config.ts
+import { existsSync } from "fs";
+import path from "path";
+import { pathToFileURL } from "url";
+var CONFIG_FILE_NAMES = [
+  "env-typegen.config.ts",
+  "env-typegen.config.mjs",
+  "env-typegen.config.js"
+];
+async function loadConfig(cwd = process.cwd()) {
+  for (const name of CONFIG_FILE_NAMES) {
+    const filePath = path.resolve(cwd, name);
+    if (existsSync(filePath)) {
+      const fileUrl = pathToFileURL(filePath).href;
+      const mod = await import(fileUrl);
+      return mod.default;
+    }
+  }
+  return void 0;
+}
+
+// src/pipeline.ts
+import path5 from "path";
+
+// src/generators/declaration-generator.ts
+import path2 from "path";
+function generateDeclaration(parsed) {
+  const fileName = path2.basename(parsed.filePath);
+  const lines = [];
+  lines.push("// Generated by env-typegen \u2014 do not edit manually");
+  lines.push(`// Source: ${fileName}`);
+  lines.push("");
+  lines.push("declare namespace NodeJS {");
+  lines.push("  interface ProcessEnv {");
+  for (const variable of parsed.vars) {
+    const effectiveType = variable.annotatedType ?? variable.inferredType;
+    const optional = variable.isOptional ? "?" : "";
+    if (variable.description !== void 0) {
+      lines.push(`    /** ${variable.description} */`);
+    }
+    let propLine = `    readonly ${variable.key}${optional}: string;`;
+    if (effectiveType === "number") {
+      propLine += ` // coerce to number: Number(process.env.${variable.key})`;
+    } else if (effectiveType === "boolean") {
+      propLine += ` // coerce to boolean: process.env.${variable.key} === 'true'`;
+    }
+    lines.push(propLine);
+  }
+  lines.push("  }");
+  lines.push("}");
+  return lines.join("\n") + "\n";
+}
+
+// src/generators/t3-generator.ts
+function toT3ZodType(envVarType) {
+  if (envVarType === "number") return "z.coerce.number()";
+  if (envVarType === "boolean") return "z.coerce.boolean()";
+  if (envVarType === "url") return "z.string().url()";
+  if (envVarType === "email") return "z.string().email()";
+  return "z.string()";
+}
+function generateT3Env(parsed) {
+  const serverVars = parsed.vars.filter((v) => !v.isClientSide);
+  const clientVars = parsed.vars.filter((v) => v.isClientSide);
+  const lines = [];
+  lines.push("// Generated by env-typegen \u2014 do not edit manually");
+  lines.push('import { createEnv } from "@t3-oss/env-nextjs";');
+  lines.push('import { z } from "zod";');
+  lines.push("");
+  lines.push("export const env = createEnv({");
+  if (serverVars.length > 0) {
+    lines.push("  server: {");
+    for (const variable of serverVars) {
+      const effectiveType = variable.annotatedType ?? variable.inferredType;
+      let zodExpr = toT3ZodType(effectiveType);
+      if (variable.description !== void 0) {
+        zodExpr += `.describe("${variable.description}")`;
+      }
+      if (variable.isOptional) {
+        zodExpr += ".optional()";
+      }
+      lines.push(`    ${variable.key}: ${zodExpr},`);
+    }
+    lines.push("  },");
+  }
+  if (clientVars.length > 0) {
+    lines.push("  client: {");
+    for (const variable of clientVars) {
+      const effectiveType = variable.annotatedType ?? variable.inferredType;
+      let zodExpr = toT3ZodType(effectiveType);
+      if (variable.description !== void 0) {
+        zodExpr += `.describe("${variable.description}")`;
+      }
+      if (variable.isOptional) {
+        zodExpr += ".optional()";
+      }
+      lines.push(`    ${variable.key}: ${zodExpr},`);
+    }
+    lines.push("  },");
+  }
+  lines.push("  runtimeEnv: {");
+  for (const variable of parsed.vars) {
+    lines.push(`    ${variable.key}: process.env.${variable.key},`);
+  }
+  lines.push("  },");
+  lines.push("});");
+  return lines.join("\n") + "\n";
+}
+
+// src/generators/typescript-generator.ts
+import path3 from "path";
+function toTsType(envVarType) {
+  if (envVarType === "number") return "number";
+  if (envVarType === "boolean") return "boolean";
+  return "string";
+}
+function generateTypeScriptTypes(parsed) {
+  const clientVars = parsed.vars.filter((v) => v.isClientSide);
+  const hasClientVars = clientVars.length > 0;
+  const fileName = path3.basename(parsed.filePath);
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  const lines = [];
+  lines.push("// Generated by env-typegen \u2014 do not edit manually");
+  lines.push(`// Source: ${fileName}`);
+  lines.push(`// Generated at: ${timestamp}`);
+  lines.push("");
+  lines.push("declare namespace NodeJS {");
+  lines.push("  interface ProcessEnv {");
+  for (const variable of parsed.vars) {
+    const effectiveType = variable.annotatedType ?? variable.inferredType;
+    const optional = variable.isOptional ? "?" : "";
+    if (variable.description !== void 0) {
+      lines.push(`    /** ${variable.description} */`);
+    }
+    let propLine = `    readonly ${variable.key}${optional}: string;`;
+    if (effectiveType === "number") {
+      propLine += ` // coerce to number: Number(process.env.${variable.key})`;
+    } else if (effectiveType === "boolean") {
+      propLine += ` // coerce to boolean: process.env.${variable.key} === 'true'`;
+    }
+    lines.push(propLine);
+  }
+  lines.push("  }");
+  lines.push("}");
+  lines.push("");
+  lines.push("export type EnvVars = {");
+  for (const variable of parsed.vars) {
+    const effectiveType = variable.annotatedType ?? variable.inferredType;
+    const tsType = toTsType(effectiveType);
+    const optional = variable.isOptional ? "?" : "";
+    lines.push(`  ${variable.key}${optional}: ${tsType};`);
+  }
+  lines.push("};");
+  if (hasClientVars) {
+    const clientKeyUnion = clientVars.map((v) => `"${v.key}"`).join(" | ");
+    lines.push("");
+    lines.push(`export type ServerEnvVars = Omit<EnvVars, ${clientKeyUnion}>;`);
+    lines.push(`export type ClientEnvVars = Pick<EnvVars, ${clientKeyUnion}>;`);
+  }
+  return lines.join("\n") + "\n";
+}
+
+// src/generators/zod-generator.ts
+function toZodType(envVarType) {
+  if (envVarType === "number") return "z.coerce.number()";
+  if (envVarType === "boolean") return "z.coerce.boolean()";
+  if (envVarType === "url") return "z.string().url()";
+  if (envVarType === "email") return "z.string().email()";
+  return "z.string()";
+}
+function generateZodSchema(parsed) {
+  const serverVars = parsed.vars.filter((v) => !v.isClientSide);
+  const clientVars = parsed.vars.filter((v) => v.isClientSide);
+  const lines = [];
+  lines.push("// Generated by env-typegen \u2014 do not edit manually");
+  lines.push('import { z } from "zod";');
+  lines.push("");
+  lines.push("export const serverEnvSchema = z.object({");
+  for (const variable of serverVars) {
+    const effectiveType = variable.annotatedType ?? variable.inferredType;
+    const zodExpr = variable.isOptional ? `${toZodType(effectiveType)}.optional()` : toZodType(effectiveType);
+    lines.push(`  ${variable.key}: ${zodExpr},`);
+  }
+  lines.push("});");
+  lines.push("");
+  lines.push("export const clientEnvSchema = z.object({");
+  for (const variable of clientVars) {
+    const effectiveType = variable.annotatedType ?? variable.inferredType;
+    const zodExpr = variable.isOptional ? `${toZodType(effectiveType)}.optional()` : toZodType(effectiveType);
+    lines.push(`  ${variable.key}: ${zodExpr},`);
+  }
+  lines.push("});");
+  lines.push("");
+  lines.push("export const envSchema = serverEnvSchema.merge(clientEnvSchema);");
+  lines.push("export type Env = z.infer<typeof envSchema>;");
+  return lines.join("\n") + "\n";
+}
+
+// src/parser/env-parser.ts
+import { readFileSync } from "fs";
+
+// src/inferrer/rules.ts
+var inferenceRules = [
+  {
+    id: "P2_key_url_suffix",
+    priority: 2,
+    match: (key) => key.toUpperCase().endsWith("_URL"),
+    type: "url"
+  },
+  {
+    id: "P3_key_email_from_suffix",
+    priority: 3,
+    match: (key) => {
+      const normalizedKey = key.toUpperCase();
+      return normalizedKey.endsWith("_EMAIL") || normalizedKey.endsWith("_FROM");
+    },
+    type: "email"
+  },
+  {
+    id: "P4_boolean_prefix",
+    priority: 4,
+    match: (key) => {
+      const normalizedKey = key.toUpperCase();
+      return normalizedKey.startsWith("ENABLE_") || normalizedKey.startsWith("DISABLE_") || normalizedKey.startsWith("IS_") || normalizedKey.startsWith("DEBUG") || normalizedKey.startsWith("FEATURE_");
+    },
+    type: "boolean"
+  },
+  {
+    id: "P5_key_port",
+    priority: 5,
+    match: (key) => {
+      const normalizedKey = key.toUpperCase();
+      return normalizedKey.endsWith("_PORT") || normalizedKey === "PORT";
+    },
+    type: "number"
+  },
+  {
+    id: "P6_empty_unknown",
+    priority: 6,
+    match: (_key, value) => value.length === 0,
+    type: "unknown"
+  },
+  {
+    id: "P7_boolean_literal",
+    priority: 7,
+    match: (_key, value) => {
+      const lower = value.toLowerCase();
+      return lower === "true" || lower === "false";
+    },
+    type: "boolean"
+  },
+  {
+    id: "P8_numeric_literal",
+    priority: 8,
+    match: (_key, value) => /^\d+(\.\d+)?$/.test(value),
+    type: "number"
+  },
+  {
+    id: "P9_semver",
+    priority: 9,
+    match: (_key, value) => /^\d+\.\d+\.\d+/.test(value),
+    type: "semver"
+  },
+  {
+    id: "P10_url_scheme",
+    priority: 10,
+    match: (_key, value) => /^[a-zA-Z][a-zA-Z0-9+.-]*:\/\//.test(value),
+    type: "url"
+  },
+  {
+    id: "P11_email_literal",
+    priority: 11,
+    match: (_key, value) => /^[^@\s]+@[^@\s]+\.[^@\s]+$/.test(value),
+    type: "email"
+  },
+  {
+    id: "P12_json_object_array",
+    priority: 12,
+    match: (_key, value) => {
+      try {
+        const parsed = JSON.parse(value);
+        return typeof parsed === "object" && parsed !== null;
+      } catch {
+        return false;
+      }
+    },
+    type: "json"
+  }
+];
+
+// src/inferrer/type-inferrer.ts
+var sortedRules = [...inferenceRules].sort((left, right) => left.priority - right.priority);
+function inferType(key, value, options) {
+  for (const rule of sortedRules) {
+    if (rule.match(key, value)) {
+      return rule.type;
+    }
+  }
+  return options?.fallbackType ?? "string";
+}
+
+// src/parser/comment-parser.ts
+var VALID_ENV_VAR_TYPES = /* @__PURE__ */ new Set([
+  "string",
+  "number",
+  "boolean",
+  "url",
+  "email",
+  "semver",
+  "json",
+  "unknown"
+]);
+function isEnvVarType(value) {
+  return VALID_ENV_VAR_TYPES.has(value);
+}
+function parseCommentBlock(lines) {
+  let annotatedType;
+  let description;
+  let isRequired = false;
+  for (const line of lines) {
+    const content = line.replace(/^#\s*/, "").trimEnd();
+    if (content.startsWith("@description ")) {
+      description = content.slice("@description ".length).trim();
+    } else if (content.startsWith("@type ")) {
+      const typeStr = content.slice("@type ".length).trim();
+      if (isEnvVarType(typeStr)) {
+        annotatedType = typeStr;
+      }
+    } else if (content.trim() === "@required") {
+      isRequired = true;
+    } else if (content.trim() === "@optional") {
+    } else if (description === void 0 && content.trim().length > 0) {
+      description = content.trim();
+    }
+  }
+  const result = { isRequired };
+  if (annotatedType !== void 0) result.annotatedType = annotatedType;
+  if (description !== void 0) result.description = description;
+  return result;
+}
+
+// src/parser/env-parser.ts
+var ENV_VAR_RE = /^([A-Z_][A-Z0-9_]*)=(.*)$/;
+var SECTION_HEADER_RE = /^#\s+[-=]{3,}\s+(.+?)\s+[-=]{3,}\s*$/;
+function parseEnvFileContent(content, filePath) {
+  const lines = content.split("\n");
+  const vars = [];
+  const groups = [];
+  let currentGroup;
+  let commentBlock = [];
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i] ?? "";
+    const lineNumber = i + 1;
+    const trimmed = line.trim();
+    if (trimmed === "") {
+      commentBlock = [];
+      continue;
+    }
+    const sectionMatch = SECTION_HEADER_RE.exec(trimmed);
+    if (sectionMatch !== null) {
+      const groupName = (sectionMatch[1] ?? "").trim();
+      currentGroup = groupName;
+      if (!groups.includes(groupName)) {
+        groups.push(groupName);
+      }
+      commentBlock = [];
+      continue;
+    }
+    if (trimmed.startsWith("#")) {
+      commentBlock.push(line);
+      continue;
+    }
+    const envMatch = ENV_VAR_RE.exec(trimmed);
+    if (envMatch !== null) {
+      const key = envMatch[1] ?? "";
+      const rawValue = envMatch[2] ?? "";
+      const annotations = parseCommentBlock(commentBlock);
+      const inferredType = inferType(key, rawValue);
+      const isRequired = rawValue.length > 0 || annotations.isRequired;
+      const isOptional = rawValue.length === 0 && !annotations.isRequired;
+      const isClientSide = key.startsWith("NEXT_PUBLIC_");
+      const parsedVar = {
+        key,
+        rawValue,
+        inferredType,
+        isRequired,
+        isOptional,
+        isClientSide,
+        lineNumber
+      };
+      if (annotations.annotatedType !== void 0) {
+        parsedVar.annotatedType = annotations.annotatedType;
+      }
+      if (annotations.description !== void 0) {
+        parsedVar.description = annotations.description;
+      }
+      if (currentGroup !== void 0) {
+        parsedVar.group = currentGroup;
+      }
+      vars.push(parsedVar);
+      commentBlock = [];
+    } else {
+      commentBlock = [];
+    }
+  }
+  return { filePath, vars, groups };
+}
+
+// src/utils/file.ts
+import { mkdir, readFile, writeFile } from "fs/promises";
+import path4 from "path";
+async function readEnvFile(filePath) {
+  return readFile(path4.resolve(filePath), "utf8");
+}
+async function writeOutput(filePath, content) {
+  const resolved = path4.resolve(filePath);
+  await mkdir(path4.dirname(resolved), { recursive: true });
+  await writeFile(resolved, content, "utf8");
+}
+
+// src/utils/format.ts
+import { format } from "prettier";
+async function formatOutput(content, parser = "typescript") {
+  try {
+    return await format(content, { parser });
+  } catch {
+    return content;
+  }
+}
+
+// src/utils/logger.ts
+var import_picocolors = __toESM(require_picocolors(), 1);
+function log(message) {
+  console.log(message);
+}
+function error(message) {
+  console.error((0, import_picocolors.red)(`\u2716 ${message}`));
+}
+function success(message) {
+  console.log((0, import_picocolors.green)(`\u2714 ${message}`));
+}
+
+// src/pipeline.ts
+function deriveOutputPath(base, generator, isSingle) {
+  if (isSingle) return base;
+  const ext = path5.extname(base);
+  const noExt = ext.length > 0 ? base.slice(0, -ext.length) : base;
+  return `${noExt}.${generator}${ext.length > 0 ? ext : ".ts"}`;
+}
+function buildOutput(generator, parsed) {
+  switch (generator) {
+    case "typescript":
+      return generateTypeScriptTypes(parsed);
+    case "zod":
+      return generateZodSchema(parsed);
+    case "t3":
+      return generateT3Env(parsed);
+    case "declaration":
+      return generateDeclaration(parsed);
+  }
+}
+async function persistOutput(params) {
+  const { generated, generator, outputPath, isSingle, stdout, dryRun, silent } = params;
+  if (stdout) {
+    if (isSingle) {
+      console.log(generated);
+    } else {
+      console.log(`// --- ${generator}:${outputPath} ---`);
+      console.log(generated);
+    }
+    return;
+  }
+  if (dryRun) {
+    if (!silent) {
+      success(`Dry run: ${outputPath}`);
+    }
+    return;
+  }
+  await writeOutput(outputPath, generated);
+  if (!silent) {
+    success(`Generated ${outputPath}`);
+  }
+}
+async function runGenerate(options) {
+  const {
+    input,
+    output,
+    generators,
+    format: shouldFormat,
+    stdout = false,
+    dryRun = false,
+    silent = false
+  } = options;
+  const isSingle = generators.length === 1;
+  const content = await readEnvFile(input);
+  const parsed = parseEnvFileContent(content, input);
+  for (const generator of generators) {
+    let generated = buildOutput(generator, parsed);
+    if (shouldFormat) {
+      generated = await formatOutput(generated);
+    }
+    const outputPath = deriveOutputPath(output, generator, isSingle);
+    await persistOutput({
+      generated,
+      generator,
+      outputPath,
+      isSingle,
+      stdout,
+      dryRun,
+      silent
+    });
+  }
+}
+
+// src/watch.ts
+import { watch } from "chokidar";
+function startWatch({ inputPath, runOptions }) {
+  log(`Watching ${inputPath} for changes...`);
+  void runGenerate(runOptions).catch((err) => {
+    const message = err instanceof Error ? err.message : JSON.stringify(err);
+    error(message);
+  });
+  const watcher = watch(inputPath, { persistent: true });
+  watcher.on("change", () => {
+    log(`${inputPath} changed, regenerating...`);
+    void runGenerate(runOptions).catch((err) => {
+      const message = err instanceof Error ? err.message : JSON.stringify(err);
+      error(message);
+    });
+  });
+  process.on("SIGINT", () => {
+    void watcher.close().then(() => {
+      log("Watcher stopped.");
+      process.exit(0);
+    });
+  });
+}
+
+// src/cli.ts
+var VERSION = "0.1.0";
+var HELP_TEXT = [
+  "env-typegen \u2014 Generate TypeScript types from .env.example",
+  "",
+  "Usage:",
+  "  env-typegen -i <path> [options]",
+  "",
+  "Options:",
+  "  -i, --input <path>         Path to .env.example file",
+  "  -o, --output <path>        Output file path (default: env.generated.ts)",
+  "  -f, --format <name>        Generator format: ts|zod|t3|declaration",
+  "                             May be specified multiple times.",
+  "  -g, --generator <name>     Backward-compatible alias for --format",
+  "      --stdout               Print generated output to stdout",
+  "      --dry-run              Parse and generate without writing files",
+  "      --no-format            Disable prettier formatting",
+  "  -s, --silent               Suppress success logs",
+  "  -w, --watch                Watch for changes and regenerate",
+  "  -c, --config <path>        Path to config file",
+  "  -v, --version              Print version",
+  "  -h, --help                 Show this help"
+].join("\n");
+var FORMAT_TO_GENERATOR = {
+  ts: "typescript",
+  typescript: "typescript",
+  zod: "zod",
+  t3: "t3",
+  declaration: "declaration"
+};
+function normalizeGenerator(input) {
+  return FORMAT_TO_GENERATOR[input] ?? FORMAT_TO_GENERATOR[input.toLowerCase()];
+}
+function getErrorMessage(errorValue) {
+  if (errorValue instanceof Error) {
+    return errorValue.message;
+  }
+  return inspect(errorValue, { depth: 2 });
+}
+async function runCli(argv = process.argv.slice(2)) {
+  const { values } = parseArgs({
+    args: argv,
+    options: {
+      input: { type: "string", short: "i" },
+      output: { type: "string", short: "o" },
+      generator: { type: "string", short: "g", multiple: true },
+      format: { type: "string", short: "f", multiple: true },
+      "no-format": { type: "boolean" },
+      stdout: { type: "boolean" },
+      "dry-run": { type: "boolean" },
+      silent: { type: "boolean", short: "s" },
+      watch: { type: "boolean", short: "w" },
+      config: { type: "string", short: "c" },
+      version: { type: "boolean", short: "v" },
+      help: { type: "boolean", short: "h" }
+    }
+  });
+  if (values.version === true) {
+    console.log(VERSION);
+    return;
+  }
+  if (values.help === true) {
+    console.log(HELP_TEXT);
+    return;
+  }
+  let fileConfig;
+  if (values.config !== void 0) {
+    const configPath = path6.resolve(values.config);
+    const mod = await import(pathToFileURL2(configPath).href);
+    fileConfig = mod.default;
+  } else {
+    fileConfig = await loadConfig(process.cwd());
+  }
+  const input = values.input ?? fileConfig?.input;
+  if (input === void 0) {
+    error("No input file specified. Use -i <path> or set input in env-typegen.config.ts");
+    process.exit(1);
+  }
+  const output = values.output ?? fileConfig?.output ?? "env.generated.ts";
+  const rawFormats = values.format;
+  const rawGenerators = values.generator;
+  const requested = [...rawFormats ?? [], ...rawGenerators ?? []].map(String);
+  let generators;
+  if (requested.length > 0) {
+    const normalizedGenerators = requested.map((item) => normalizeGenerator(item)).filter((item) => item !== void 0);
+    const invalid = requested.filter((item) => normalizeGenerator(item) === void 0);
+    if (invalid.length > 0) {
+      error(`Unknown format(s): ${invalid.join(", ")}. Valid: ts, zod, t3, declaration`);
+      process.exit(1);
+    }
+    generators = [...new Set(normalizedGenerators)];
+  } else {
+    generators = fileConfig?.generators ?? ["typescript"];
+  }
+  const shouldFormat = values["no-format"] === true ? false : fileConfig?.format ?? true;
+  const useStdout = values.stdout ?? false;
+  const isDryRun = values["dry-run"] ?? false;
+  const isSilent = values.silent ?? false;
+  const shouldWatch = values.watch ?? false;
+  const options = {
+    input,
+    output,
+    generators,
+    format: shouldFormat,
+    stdout: useStdout,
+    dryRun: isDryRun,
+    silent: isSilent
+  };
+  if (shouldWatch) {
+    startWatch({ inputPath: input, runOptions: options });
+  } else {
+    await runGenerate(options);
+  }
+}
+if (process.argv[1] !== void 0 && path6.resolve(process.argv[1]) === path6.resolve(fileURLToPath(import.meta.url))) {
+  await runCli().catch((err) => {
+    error(getErrorMessage(err));
+    process.exit(1);
+  });
+}
+export {
+  runCli,
+  runGenerate
+};
+//# sourceMappingURL=cli.js.map