@ayronforge/envil 0.6.0

package/dist/cli.js

@@ -0,0 +1,1249 @@
+#!/usr/bin/env node
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined")
+    return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/cli/fs-utils.ts
+import { access, mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import path from "node:path";
+async function pathExists(filePath) {
+  try {
+    await access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function resolveFromCwd(cwd, filePath) {
+  return path.isAbsolute(filePath) ? filePath : path.resolve(cwd, filePath);
+}
+async function getDefaultEnvOutputPath(cwd) {
+  const srcDir = path.join(cwd, "src");
+  if (await pathExists(srcDir)) {
+    return path.join(srcDir, "env.ts");
+  }
+  return path.join(cwd, "env.ts");
+}
+async function getDefaultExampleInputPath(cwd) {
+  const rootEnv = path.join(cwd, "env.ts");
+  const srcEnv = path.join(cwd, "src", "env.ts");
+  if (await pathExists(rootEnv))
+    return rootEnv;
+  if (await pathExists(srcEnv))
+    return srcEnv;
+  const srcDir = path.join(cwd, "src");
+  if (await pathExists(srcDir)) {
+    return srcEnv;
+  }
+  return rootEnv;
+}
+async function ensureWritableTarget(targetPath, force) {
+  if (!force && await pathExists(targetPath)) {
+    throw new Error(`Target file "${targetPath}" already exists. Use --force to overwrite.`);
+  }
+}
+async function readTextFileOrThrow(filePath, label) {
+  try {
+    return await readFile(filePath, "utf8");
+  } catch (error) {
+    throw new Error(`Unable to read ${label} at "${filePath}": ${String(error)}`);
+  }
+}
+async function writeFileAtomic(targetPath, contents) {
+  const directory = path.dirname(targetPath);
+  await mkdir(directory, { recursive: true });
+  const tempPath = path.join(directory, `.envil-tmp-${process.pid}-${Date.now()}-${Math.random().toString(16).slice(2)}`);
+  await writeFile(tempPath, contents, "utf8");
+  await rename(tempPath, targetPath);
+}
+
+// src/cli/dotenv-codec.ts
+import { Schema } from "effect";
+
+// src/cli/literals.ts
+function parseLiteral(input) {
+  const trimmed = input.trim();
+  if (trimmed.length === 0) {
+    return "";
+  }
+  if (trimmed.startsWith('"') && trimmed.endsWith('"') || trimmed.startsWith("'") && trimmed.endsWith("'")) {
+    try {
+      return JSON.parse(trimmed.replace(/^'/, '"').replace(/'$/, '"'));
+    } catch {
+      return trimmed.slice(1, -1);
+    }
+  }
+  if (trimmed === "true")
+    return true;
+  if (trimmed === "false")
+    return false;
+  if (trimmed === "null")
+    return null;
+  if (/^[+-]?\d+(?:\.\d+)?$/.test(trimmed)) {
+    const value = Number(trimmed);
+    if (!Number.isNaN(value)) {
+      return value;
+    }
+  }
+  if (trimmed.startsWith("{") && trimmed.endsWith("}") || trimmed.startsWith("[") && trimmed.endsWith("]")) {
+    try {
+      return JSON.parse(trimmed);
+    } catch {
+      return trimmed;
+    }
+  }
+  return trimmed;
+}
+function toCodeLiteral(value) {
+  if (typeof value === "string")
+    return JSON.stringify(value);
+  if (typeof value === "number" || typeof value === "boolean")
+    return String(value);
+  if (value === null)
+    return "null";
+  if (value === undefined)
+    return "undefined";
+  return JSON.stringify(value);
+}
+function toDirectiveLiteral(value) {
+  if (value === undefined)
+    return "";
+  return toCodeLiteral(value);
+}
+function toEnvValueLiteral(value) {
+  if (typeof value === "string")
+    return value;
+  if (typeof value === "number" || typeof value === "boolean")
+    return String(value);
+  if (value === null || value === undefined)
+    return "";
+  return JSON.stringify(value);
+}
+function parseBooleanDirective(value, defaultValue) {
+  if (value === undefined || value.length === 0) {
+    return defaultValue;
+  }
+  const normalized = value.trim().toLowerCase();
+  if (normalized === "true")
+    return true;
+  if (normalized === "false")
+    return false;
+  throw new Error(`Invalid boolean directive value "${value}"`);
+}
+
+// src/cli/types.ts
+var BUCKETS = ["server", "client", "shared"];
+var SCHEMA_KINDS = [
+  "requiredString",
+  "boolean",
+  "integer",
+  "number",
+  "port",
+  "url",
+  "postgresUrl",
+  "redisUrl",
+  "mongoUrl",
+  "mysqlUrl",
+  "commaSeparated",
+  "commaSeparatedNumbers",
+  "commaSeparatedUrls",
+  "json"
+];
+var FRAMEWORKS = ["nextjs", "vite", "expo", "nuxt", "sveltekit", "astro"];
+var MANIFEST_VERSION = 1;
+
+// src/cli/dotenv-codec.ts
+var SENTINEL_DIRECTIVE_PREFIX = "@";
+var KEY_ASSIGNMENT_PATTERN = /^([A-Za-z_][A-Za-z0-9_]*)\s*=(.*)$/;
+var DotenvCodec = Schema.transform(Schema.String, Schema.Unknown, {
+  decode: (text) => parseDotenvText(String(text)),
+  encode: (value) => stringifyDotenvDocument(value)
+});
+function decodeDotenvText(text) {
+  return Schema.decodeUnknownSync(DotenvCodec)(text);
+}
+function encodeDotenvText(document) {
+  return Schema.encodeSync(DotenvCodec)(document);
+}
+function parseDotenvText(text) {
+  const lines = text.split(/\r?\n/);
+  const entries = [];
+  let activeBucket;
+  let pendingDirectives = {};
+  for (const [index, line] of lines.entries()) {
+    const lineNumber = index + 1;
+    const trimmed = line.trim();
+    if (trimmed.length === 0) {
+      continue;
+    }
+    if (trimmed.startsWith("#")) {
+      const comment = trimmed.slice(1).trim();
+      if (comment.startsWith(SENTINEL_DIRECTIVE_PREFIX)) {
+        const directiveResult = parseDirectiveGroup(comment, lineNumber, pendingDirectives);
+        if (directiveResult.sectionBucket) {
+          activeBucket = directiveResult.sectionBucket;
+          pendingDirectives = {};
+        } else {
+          pendingDirectives = directiveResult.directives;
+        }
+      }
+      continue;
+    }
+    const assignmentMatch = KEY_ASSIGNMENT_PATTERN.exec(trimmed);
+    if (!assignmentMatch) {
+      throw new Error(`Malformed assignment at line ${lineNumber}: "${line}"`);
+    }
+    const key = assignmentMatch[1];
+    const rightHandSide = assignmentMatch[2];
+    const split = splitValueAndInlineComment(rightHandSide);
+    const value = normalizeAssignedValue(split.value.trim());
+    let directives = { ...pendingDirectives };
+    if (split.comment) {
+      const inlineComment = split.comment.trim();
+      if (inlineComment.startsWith(SENTINEL_DIRECTIVE_PREFIX)) {
+        const parsedInline = parseDirectiveGroup(inlineComment, lineNumber, directives);
+        if (parsedInline.sectionBucket) {
+          throw new Error(`Section directives are not allowed inline at line ${lineNumber}`);
+        }
+        directives = parsedInline.directives;
+      }
+    }
+    entries.push({
+      key,
+      value,
+      line: lineNumber,
+      sectionBucket: activeBucket,
+      directives
+    });
+    pendingDirectives = {};
+  }
+  return { entries };
+}
+function stringifyDotenvDocument(document) {
+  if (!document || !Array.isArray(document.entries)) {
+    throw new Error("Invalid dotenv document: expected an entries array");
+  }
+  const grouped = {
+    server: [],
+    client: [],
+    shared: []
+  };
+  const sortedEntries = [...document.entries].sort((left, right) => {
+    if (left.line !== right.line)
+      return left.line - right.line;
+    return left.key.localeCompare(right.key);
+  });
+  for (const entry of sortedEntries) {
+    const bucket = entry.directives.bucket ?? entry.sectionBucket ?? "server";
+    grouped[bucket].push(entry);
+  }
+  const lines = [];
+  for (const bucket of BUCKETS) {
+    lines.push(`# @${bucket}`);
+    lines.push("");
+    for (const entry of grouped[bucket]) {
+      const type = entry.directives.type ?? "requiredString";
+      const optional = entry.directives.optional ?? false;
+      const hasDefault = entry.directives.hasDefault ?? false;
+      const redacted = entry.directives.redacted ?? false;
+      const defaultLiteral = hasDefault ? ` ${toDirectiveLiteral(entry.directives.defaultValue)}` : "";
+      lines.push(`# @type ${type}`);
+      lines.push(`# @bucket ${bucket}`);
+      lines.push(`# @optional ${optional}`);
+      lines.push(`# @default${defaultLiteral}`);
+      lines.push(`# @redacted ${redacted}`);
+      lines.push(`${entry.key}=${serializeEnvValue(entry.value)}`);
+      lines.push("");
+    }
+  }
+  while (lines.length > 0 && lines[lines.length - 1] === "") {
+    lines.pop();
+  }
+  return `${lines.join(`
+`)}
+`;
+}
+function splitValueAndInlineComment(value) {
+  let inSingleQuote = false;
+  let inDoubleQuote = false;
+  let escaped = false;
+  for (let index = 0;index < value.length; index += 1) {
+    const char = value[index];
+    if (escaped) {
+      escaped = false;
+      continue;
+    }
+    if (char === "\\") {
+      escaped = true;
+      continue;
+    }
+    if (char === "'" && !inDoubleQuote) {
+      inSingleQuote = !inSingleQuote;
+      continue;
+    }
+    if (char === '"' && !inSingleQuote) {
+      inDoubleQuote = !inDoubleQuote;
+      continue;
+    }
+    if (!inSingleQuote && !inDoubleQuote && char === "#") {
+      return {
+        value: value.slice(0, index).trimEnd(),
+        comment: value.slice(index + 1)
+      };
+    }
+  }
+  return { value };
+}
+function parseDirectiveGroup(directiveText, lineNumber, base) {
+  const directives = { ...base };
+  const tokens = directiveText.split(/\s+(?=@)/g).map((token) => token.trim()).filter(Boolean);
+  let sectionBucket;
+  for (const token of tokens) {
+    const parsed = parseDirectiveToken(token, lineNumber);
+    if ("type" in parsed)
+      directives.type = parsed.type;
+    if ("optional" in parsed)
+      directives.optional = parsed.optional;
+    if ("hasDefault" in parsed)
+      directives.hasDefault = parsed.hasDefault;
+    if ("defaultValue" in parsed)
+      directives.defaultValue = parsed.defaultValue;
+    if ("redacted" in parsed)
+      directives.redacted = parsed.redacted;
+    if ("bucket" in parsed)
+      directives.bucket = parsed.bucket;
+    if ("sectionBucket" in parsed)
+      sectionBucket = parsed.sectionBucket;
+  }
+  return { directives, sectionBucket };
+}
+function parseDirectiveToken(token, lineNumber) {
+  if (!token.startsWith("@")) {
+    throw new Error(`Malformed directive at line ${lineNumber}: "${token}"`);
+  }
+  const spaceIndex = token.indexOf(" ");
+  const name = (spaceIndex === -1 ? token.slice(1) : token.slice(1, spaceIndex)).trim();
+  const value = (spaceIndex === -1 ? "" : token.slice(spaceIndex + 1)).trim();
+  if (name === "server" || name === "client" || name === "shared") {
+    if (value.length > 0) {
+      throw new Error(`Section directive "@${name}" must not include a value (line ${lineNumber})`);
+    }
+    return { sectionBucket: name };
+  }
+  if (name === "type") {
+    if (value.length === 0) {
+      throw new Error(`Directive "@type" requires a value at line ${lineNumber}`);
+    }
+    return { type: parseSchemaKind(value, lineNumber) };
+  }
+  if (name === "optional") {
+    return { optional: parseBooleanDirective(value || undefined, true) };
+  }
+  if (name === "default") {
+    if (value.length === 0) {
+      return { hasDefault: false, defaultValue: undefined };
+    }
+    return { hasDefault: true, defaultValue: parseLiteral(value) };
+  }
+  if (name === "redacted") {
+    return { redacted: parseBooleanDirective(value || undefined, true) };
+  }
+  if (name === "bucket") {
+    if (value.length === 0) {
+      throw new Error(`Directive "@bucket" requires a value at line ${lineNumber}`);
+    }
+    if (!isBucket(value)) {
+      throw new Error(`Invalid bucket "${value}" at line ${lineNumber}`);
+    }
+    return { bucket: value };
+  }
+  throw new Error(`Unknown directive "@${name}" at line ${lineNumber}`);
+}
+function parseSchemaKind(rawValue, lineNumber) {
+  const normalized = rawValue.trim().toLowerCase();
+  const aliasMap = {
+    string: "requiredString",
+    requiredstring: "requiredString",
+    bool: "boolean",
+    boolean: "boolean",
+    int: "integer",
+    integer: "integer",
+    number: "number",
+    port: "port",
+    url: "url",
+    postgresurl: "postgresUrl",
+    redisurl: "redisUrl",
+    mongourl: "mongoUrl",
+    mysqlurl: "mysqlUrl",
+    commaseparated: "commaSeparated",
+    commaseparatednumbers: "commaSeparatedNumbers",
+    commaseparatedurls: "commaSeparatedUrls",
+    json: "json",
+    "json(schema.unknown)": "json"
+  };
+  const resolved = aliasMap[normalized];
+  if (!resolved || !SCHEMA_KINDS.includes(resolved)) {
+    throw new Error(`Invalid @type value "${rawValue}" at line ${lineNumber}`);
+  }
+  return resolved;
+}
+function normalizeAssignedValue(value) {
+  if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+    return value.slice(1, -1);
+  }
+  return value;
+}
+function serializeEnvValue(value) {
+  const literal = toEnvValueLiteral(value);
+  if (literal.length === 0)
+    return "";
+  if (/[\s#]/.test(literal)) {
+    return JSON.stringify(literal);
+  }
+  return literal;
+}
+function isBucket(value) {
+  return BUCKETS.includes(value);
+}
+// src/cli/generate-example.ts
+var PLACEHOLDERS = {
+  requiredString: "CHANGE_ME",
+  boolean: "true",
+  integer: "123",
+  number: "3.14",
+  port: "3000",
+  url: "https://example.com",
+  postgresUrl: "postgres://user:pass@localhost:5432/app",
+  redisUrl: "redis://localhost:6379",
+  mongoUrl: "mongodb://localhost:27017/app",
+  mysqlUrl: "mysql://user:pass@localhost:3306/app",
+  commaSeparated: "alpha,beta,gamma",
+  commaSeparatedNumbers: "1,2,3",
+  commaSeparatedUrls: "https://one.example.com,https://two.example.com",
+  json: '{"key":"value"}'
+};
+function generateExample(manifest) {
+  const entries = [];
+  let line = 1;
+  for (const bucket of BUCKETS) {
+    const variables = manifest.variables.filter((variable) => variable.bucket === bucket).sort((left, right) => left.name.localeCompare(right.name));
+    for (const variable of variables) {
+      const runtimeKey = `${manifest.prefix[bucket]}${variable.name}`;
+      const value = variable.hasDefault ? renderDefaultValue(variable) : PLACEHOLDERS[variable.kind] ?? PLACEHOLDERS.requiredString;
+      entries.push({
+        key: runtimeKey,
+        value,
+        line,
+        sectionBucket: bucket,
+        directives: {
+          type: variable.kind,
+          bucket,
+          optional: variable.optional,
+          hasDefault: variable.hasDefault,
+          defaultValue: variable.defaultValue,
+          redacted: variable.redacted
+        }
+      });
+      line += 1;
+    }
+  }
+  return encodeDotenvText({ entries });
+}
+function renderDefaultValue(variable) {
+  if (!variable.hasDefault) {
+    return PLACEHOLDERS[variable.kind];
+  }
+  if (variable.kind === "commaSeparated") {
+    if (Array.isArray(variable.defaultValue)) {
+      return variable.defaultValue.map((item) => String(item)).join(",");
+    }
+    return String(variable.defaultValue ?? "");
+  }
+  if (variable.kind === "commaSeparatedNumbers") {
+    if (Array.isArray(variable.defaultValue)) {
+      return variable.defaultValue.map((item) => Number(item)).filter((item) => Number.isFinite(item)).join(",");
+    }
+    return String(variable.defaultValue ?? "0");
+  }
+  if (variable.kind === "commaSeparatedUrls") {
+    if (Array.isArray(variable.defaultValue)) {
+      return variable.defaultValue.map((item) => String(item)).join(",");
+    }
+    return String(variable.defaultValue ?? PLACEHOLDERS.commaSeparatedUrls);
+  }
+  if (variable.kind === "json") {
+    if (typeof variable.defaultValue === "string") {
+      return variable.defaultValue;
+    }
+    return JSON.stringify(variable.defaultValue ?? {});
+  }
+  return toEnvValueLiteral(variable.defaultValue);
+}
+// src/cli/manifest-codec.ts
+import { Schema as Schema2 } from "effect";
+var MANIFEST_SENTINEL = "@envil:manifest";
+var MANIFEST_BLOCK_PATTERN = /\/\*\s*@envil:manifest\s*([\s\S]*?)\*\//m;
+var ManifestCodec = Schema2.transform(Schema2.String, Schema2.Unknown, {
+  decode: (source) => decodeManifestFromSourceText(String(source)),
+  encode: (value) => encodeManifestToBlockComment(value)
+});
+function decodeManifestFromSource(source) {
+  return Schema2.decodeUnknownSync(ManifestCodec)(source);
+}
+function encodeManifestBlock(manifest) {
+  return Schema2.encodeSync(ManifestCodec)(manifest);
+}
+function decodeManifestFromSourceText(source) {
+  const match = MANIFEST_BLOCK_PATTERN.exec(source);
+  if (!match) {
+    throw new Error("Manifest block not found. Expected a top-level @envil:manifest block comment.");
+  }
+  const jsonText = match[1].trim();
+  let parsed;
+  try {
+    parsed = JSON.parse(jsonText);
+  } catch (error) {
+    throw new Error(`Malformed manifest JSON: ${String(error)}`);
+  }
+  return validateManifest(parsed);
+}
+function encodeManifestToBlockComment(manifest) {
+  const normalized = validateManifest(manifest);
+  return `/* ${MANIFEST_SENTINEL}
+${JSON.stringify(normalized, null, 2)}
+*/`;
+}
+function validateManifest(value) {
+  if (!value || typeof value !== "object") {
+    throw new Error("Manifest must be an object.");
+  }
+  const candidate = value;
+  if (candidate.version !== MANIFEST_VERSION) {
+    throw new Error(`Unsupported manifest version "${String(candidate.version)}".`);
+  }
+  const prefix = validatePrefix(candidate.prefix);
+  const variablesRaw = candidate.variables;
+  if (!Array.isArray(variablesRaw)) {
+    throw new Error('Manifest field "variables" must be an array.');
+  }
+  const variables = variablesRaw.map((item, index) => validateManifestVariable(item, index));
+  variables.sort((left, right) => {
+    if (left.bucket !== right.bucket)
+      return left.bucket.localeCompare(right.bucket);
+    return left.name.localeCompare(right.name);
+  });
+  return {
+    version: MANIFEST_VERSION,
+    prefix,
+    variables
+  };
+}
+function validatePrefix(prefixValue) {
+  if (!prefixValue || typeof prefixValue !== "object") {
+    throw new Error('Manifest field "prefix" must be an object.');
+  }
+  const prefix = prefixValue;
+  const server = typeof prefix.server === "string" ? prefix.server : "";
+  const client = typeof prefix.client === "string" ? prefix.client : "";
+  const shared = typeof prefix.shared === "string" ? prefix.shared : "";
+  return { server, client, shared };
+}
+function validateManifestVariable(value, index) {
+  if (!value || typeof value !== "object") {
+    throw new Error(`Manifest variable at index ${index} must be an object.`);
+  }
+  const variable = value;
+  if (typeof variable.name !== "string" || variable.name.length === 0) {
+    throw new Error(`Manifest variable at index ${index} has an invalid "name".`);
+  }
+  if (typeof variable.bucket !== "string" || !BUCKETS.includes(variable.bucket)) {
+    throw new Error(`Manifest variable "${variable.name}" has an invalid "bucket".`);
+  }
+  if (typeof variable.kind !== "string" || !SCHEMA_KINDS.includes(variable.kind)) {
+    throw new Error(`Manifest variable "${variable.name}" has an invalid "kind".`);
+  }
+  if (typeof variable.optional !== "boolean") {
+    throw new Error(`Manifest variable "${variable.name}" has an invalid "optional" flag.`);
+  }
+  if (typeof variable.hasDefault !== "boolean") {
+    throw new Error(`Manifest variable "${variable.name}" has an invalid "hasDefault" flag.`);
+  }
+  if (typeof variable.redacted !== "boolean") {
+    throw new Error(`Manifest variable "${variable.name}" has an invalid "redacted" flag.`);
+  }
+  return {
+    name: variable.name,
+    bucket: variable.bucket,
+    kind: variable.kind,
+    optional: variable.optional,
+    hasDefault: variable.hasDefault,
+    defaultValue: variable.defaultValue,
+    redacted: variable.redacted
+  };
+}
+
+// src/cli/generate-env-ts.ts
+function generateEnvTs(model) {
+  const sortedVariables = [...model.variables].sort((left, right) => {
+    if (left.bucket !== right.bucket)
+      return left.bucket.localeCompare(right.bucket);
+    return left.schemaKey.localeCompare(right.schemaKey);
+  });
+  const grouped = {
+    server: [],
+    client: [],
+    shared: []
+  };
+  const helperImports = new Set(["createEnv"]);
+  let needsSchemaImport = false;
+  for (const variable of sortedVariables) {
+    const rendered = renderSchemaExpression(variable.kind, {
+      optional: variable.optional,
+      hasDefault: variable.hasDefault,
+      defaultValue: variable.defaultValue,
+      redacted: variable.redacted
+    });
+    for (const helper of rendered.helpers) {
+      helperImports.add(helper);
+    }
+    needsSchemaImport ||= rendered.needsSchemaImport;
+    grouped[variable.bucket].push({
+      key: quoteObjectKey(variable.schemaKey),
+      expression: rendered.expression
+    });
+  }
+  const importLine = `import { ${[...helperImports].sort().join(", ")} } from "@ayronforge/envil";`;
+  const schemaImportLine = needsSchemaImport ? `import { Schema } from "effect";` : "";
+  const manifestBlock = encodeManifestBlock(toManifest(model));
+  const sourceLines = [
+    manifestBlock,
+    "",
+    importLine,
+    schemaImportLine,
+    "",
+    "export const envDefinition = {",
+    "  prefix: {",
+    `    server: ${JSON.stringify(model.prefix.server)},`,
+    `    client: ${JSON.stringify(model.prefix.client)},`,
+    `    shared: ${JSON.stringify(model.prefix.shared)},`,
+    "  },",
+    "  server: {",
+    ...renderBucketEntries(grouped.server),
+    "  },",
+    "  client: {",
+    ...renderBucketEntries(grouped.client),
+    "  },",
+    "  shared: {",
+    ...renderBucketEntries(grouped.shared),
+    "  },",
+    "} as const;",
+    "",
+    "export const env = createEnv(envDefinition);",
+    ""
+  ];
+  return sourceLines.filter((line, index, all) => line !== "" || all[index - 1] !== "").join(`
+`);
+}
+function renderBucketEntries(entries) {
+  if (entries.length === 0) {
+    return [];
+  }
+  return entries.map((entry) => `    ${entry.key}: ${entry.expression},`);
+}
+function renderSchemaExpression(kind, wrappers) {
+  let expression = renderBaseExpression(kind);
+  const helpers = new Set(requiredHelpersForKind(kind));
+  const needsSchemaImport = kind === "number" || kind === "json";
+  if (wrappers.optional && !wrappers.hasDefault) {
+    expression = `optional(${expression})`;
+    helpers.add("optional");
+  }
+  if (wrappers.hasDefault) {
+    expression = `withDefault(${expression}, ${toCodeLiteral(wrappers.defaultValue)})`;
+    helpers.add("withDefault");
+  }
+  if (wrappers.redacted) {
+    expression = `redacted(${expression})`;
+    helpers.add("redacted");
+  }
+  return { expression, helpers, needsSchemaImport };
+}
+function renderBaseExpression(kind) {
+  switch (kind) {
+    case "requiredString":
+      return "requiredString";
+    case "boolean":
+      return "boolean";
+    case "integer":
+      return "integer";
+    case "number":
+      return "Schema.NumberFromString";
+    case "port":
+      return "port";
+    case "url":
+      return "url";
+    case "postgresUrl":
+      return "postgresUrl";
+    case "redisUrl":
+      return "redisUrl";
+    case "mongoUrl":
+      return "mongoUrl";
+    case "mysqlUrl":
+      return "mysqlUrl";
+    case "commaSeparated":
+      return "commaSeparated";
+    case "commaSeparatedNumbers":
+      return "commaSeparatedNumbers";
+    case "commaSeparatedUrls":
+      return "commaSeparatedUrls";
+    case "json":
+      return "json(Schema.Unknown)";
+    default:
+      return "requiredString";
+  }
+}
+function requiredHelpersForKind(kind) {
+  switch (kind) {
+    case "requiredString":
+      return ["requiredString"];
+    case "boolean":
+      return ["boolean"];
+    case "integer":
+      return ["integer"];
+    case "number":
+      return [];
+    case "port":
+      return ["port"];
+    case "url":
+      return ["url"];
+    case "postgresUrl":
+      return ["postgresUrl"];
+    case "redisUrl":
+      return ["redisUrl"];
+    case "mongoUrl":
+      return ["mongoUrl"];
+    case "mysqlUrl":
+      return ["mysqlUrl"];
+    case "commaSeparated":
+      return ["commaSeparated"];
+    case "commaSeparatedNumbers":
+      return ["commaSeparatedNumbers"];
+    case "commaSeparatedUrls":
+      return ["commaSeparatedUrls"];
+    case "json":
+      return ["json"];
+    default:
+      return ["requiredString"];
+  }
+}
+function quoteObjectKey(value) {
+  return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(value) ? value : JSON.stringify(value);
+}
+function toManifest(model) {
+  const variables = [...model.variables].map((variable) => ({
+    name: variable.schemaKey,
+    bucket: variable.bucket,
+    kind: variable.kind,
+    optional: variable.optional,
+    hasDefault: variable.hasDefault,
+    defaultValue: variable.defaultValue,
+    redacted: variable.redacted
+  })).sort((left, right) => {
+    if (left.bucket !== right.bucket)
+      return left.bucket.localeCompare(right.bucket);
+    return left.name.localeCompare(right.name);
+  });
+  return {
+    version: MANIFEST_VERSION,
+    prefix: model.prefix,
+    variables
+  };
+}
+// src/cli/infer.ts
+var STRING_KINDS = new Set([
+  "requiredString",
+  "url",
+  "postgresUrl",
+  "redisUrl",
+  "mongoUrl",
+  "mysqlUrl"
+]);
+var BUCKET_ORDER = {
+  server: 0,
+  client: 1,
+  shared: 2
+};
+function inferModel(document, options) {
+  const runtimeEnv = {};
+  const inferredVariables = [];
+  for (const entry of document.entries) {
+    runtimeEnv[entry.key] = entry.value;
+    const { bucket, schemaKey } = resolveBucketAndSchemaKey(entry.key, options.prefix, {
+      explicitBucket: entry.directives.bucket,
+      sectionBucket: entry.sectionBucket
+    });
+    const resolvedKind = entry.directives.type ?? inferSchemaKind(entry.key, entry.value);
+    const hasDefault = entry.directives.hasDefault ?? false;
+    const defaultValue = hasDefault ? normalizeDefaultValue(resolvedKind, entry.directives.defaultValue) : undefined;
+    const optionalFlag = entry.directives.optional ?? false;
+    const redactedFlag = entry.directives.redacted ?? false;
+    const duplicate = inferredVariables.find((candidate) => candidate.bucket === bucket && candidate.schemaKey === schemaKey);
+    if (duplicate) {
+      throw new Error(`Duplicate schema key "${schemaKey}" in bucket "${bucket}" at line ${entry.line}.`);
+    }
+    inferredVariables.push({
+      schemaKey,
+      runtimeKey: entry.key,
+      bucket,
+      kind: resolvedKind,
+      optional: optionalFlag,
+      hasDefault,
+      defaultValue,
+      redacted: redactedFlag,
+      sourceLine: entry.line
+    });
+  }
+  inferredVariables.sort((left, right) => {
+    const bucketOrder = BUCKET_ORDER[left.bucket] - BUCKET_ORDER[right.bucket];
+    if (bucketOrder !== 0)
+      return bucketOrder;
+    return left.schemaKey.localeCompare(right.schemaKey);
+  });
+  return {
+    prefix: options.prefix,
+    variables: inferredVariables,
+    runtimeEnv
+  };
+}
+function resolveBucketAndSchemaKey(runtimeKey, prefix, options) {
+  const explicitBucket = options.explicitBucket ?? options.sectionBucket;
+  if (explicitBucket) {
+    return {
+      bucket: explicitBucket,
+      schemaKey: stripPrefix(runtimeKey, prefix[explicitBucket])
+    };
+  }
+  const inferredFromPrefix = inferBucketFromPrefix(runtimeKey, prefix);
+  if (inferredFromPrefix) {
+    return inferredFromPrefix;
+  }
+  return {
+    bucket: "server",
+    schemaKey: runtimeKey
+  };
+}
+function inferBucketFromPrefix(runtimeKey, prefix) {
+  const candidates = [
+    { bucket: "client", prefix: prefix.client },
+    { bucket: "server", prefix: prefix.server },
+    { bucket: "shared", prefix: prefix.shared }
+  ].filter((candidate) => candidate.prefix.length > 0 && runtimeKey.startsWith(candidate.prefix)).sort((left, right) => right.prefix.length - left.prefix.length);
+  const best = candidates[0];
+  if (!best)
+    return;
+  return {
+    bucket: best.bucket,
+    schemaKey: stripPrefix(runtimeKey, best.prefix)
+  };
+}
+function stripPrefix(key, prefix) {
+  if (!prefix || !key.startsWith(prefix)) {
+    return key;
+  }
+  const stripped = key.slice(prefix.length);
+  return stripped.length > 0 ? stripped : key;
+}
+function inferSchemaKind(key, rawValue) {
+  const value = rawValue.trim();
+  const lowerValue = value.toLowerCase();
+  const upperKey = key.toUpperCase();
+  if (isJsonCandidate(value)) {
+    return "json";
+  }
+  if (lowerValue.startsWith("postgres://") || lowerValue.startsWith("postgresql://")) {
+    return "postgresUrl";
+  }
+  if (lowerValue.startsWith("redis://") || lowerValue.startsWith("rediss://")) {
+    return "redisUrl";
+  }
+  if (lowerValue.startsWith("mongodb://") || lowerValue.startsWith("mongodb+srv://")) {
+    return "mongoUrl";
+  }
+  if (lowerValue.startsWith("mysql://") || lowerValue.startsWith("mysqls://")) {
+    return "mysqlUrl";
+  }
+  if (isCommaSeparatedCandidate(value)) {
+    const parts = splitCommaValues(value);
+    if (parts.length > 0 && parts.every((part) => isIntegerString(part) || isNumberString(part))) {
+      return "commaSeparatedNumbers";
+    }
+    if (parts.length > 0 && parts.every((part) => isHttpUrl(part))) {
+      return "commaSeparatedUrls";
+    }
+    return "commaSeparated";
+  }
+  if (isHttpUrl(value)) {
+    return "url";
+  }
+  if (isBooleanString(lowerValue)) {
+    return "boolean";
+  }
+  if (isIntegerString(value)) {
+    const numberValue = Number(value);
+    if (upperKey.includes("PORT") && numberValue >= 1 && numberValue <= 65535) {
+      return "port";
+    }
+    return "integer";
+  }
+  if (isNumberString(value)) {
+    return "number";
+  }
+  return "requiredString";
+}
+function isBooleanString(value) {
+  return value === "true" || value === "false" || value === "1" || value === "0";
+}
+function isIntegerString(value) {
+  return /^[+-]?\d+$/.test(value);
+}
+function isNumberString(value) {
+  return /^[+-]?(?:\d+\.?\d*|\.\d+)$/.test(value);
+}
+function isHttpUrl(value) {
+  try {
+    const parsed = new URL(value);
+    return parsed.protocol === "http:" || parsed.protocol === "https:";
+  } catch {
+    return false;
+  }
+}
+function isCommaSeparatedCandidate(value) {
+  return value.includes(",") && !value.startsWith("{") && !value.startsWith("[");
+}
+function splitCommaValues(value) {
+  return value.split(",").map((part) => part.trim()).filter((part) => part.length > 0);
+}
+function isJsonCandidate(value) {
+  const trimmed = value.trim();
+  if (!(trimmed.startsWith("{") && trimmed.endsWith("}") || trimmed.startsWith("[") && trimmed.endsWith("]"))) {
+    return false;
+  }
+  try {
+    JSON.parse(trimmed);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function normalizeDefaultValue(kind, value) {
+  if (kind === "boolean") {
+    if (typeof value === "boolean")
+      return value;
+    if (typeof value === "string") {
+      const normalized = value.toLowerCase();
+      return normalized === "true" || normalized === "1";
+    }
+    return Boolean(value);
+  }
+  if (kind === "integer") {
+    const numeric = Number(value);
+    if (!Number.isFinite(numeric))
+      return 0;
+    return Math.trunc(numeric);
+  }
+  if (kind === "number") {
+    const numeric = Number(value);
+    return Number.isFinite(numeric) ? numeric : 0;
+  }
+  if (kind === "port") {
+    const numeric = Math.trunc(Number(value));
+    if (Number.isFinite(numeric) && numeric >= 1 && numeric <= 65535) {
+      return numeric;
+    }
+    return 3000;
+  }
+  if (kind === "commaSeparated") {
+    if (Array.isArray(value)) {
+      return value.map((item) => String(item));
+    }
+    if (typeof value === "string") {
+      return splitCommaValues(value);
+    }
+    return [String(value ?? "")];
+  }
+  if (kind === "commaSeparatedNumbers") {
+    if (Array.isArray(value)) {
+      return value.map((item) => Number(item)).filter((item) => Number.isFinite(item));
+    }
+    if (typeof value === "string") {
+      return splitCommaValues(value).map((item) => Number(item)).filter((item) => Number.isFinite(item));
+    }
+    const numeric = Number(value);
+    return Number.isFinite(numeric) ? [numeric] : [0];
+  }
+  if (kind === "commaSeparatedUrls") {
+    if (Array.isArray(value)) {
+      return value.map((item) => String(item));
+    }
+    if (typeof value === "string") {
+      return splitCommaValues(value);
+    }
+    return [String(value ?? "https://example.com")];
+  }
+  if (kind === "json") {
+    return value ?? {};
+  }
+  if (STRING_KINDS.has(kind)) {
+    const stringValue = String(value ?? "");
+    return stringValue.length > 0 ? stringValue : "value";
+  }
+  return value;
+}
+// src/cli.ts
+var DEFAULT_IO = {
+  cwd: () => process.cwd(),
+  stdout: (message) => process.stdout.write(message),
+  stderr: (message) => process.stderr.write(message)
+};
+var FRAMEWORK_PREFIXES = {
+  nextjs: { server: "", client: "NEXT_PUBLIC_", shared: "" },
+  vite: { server: "", client: "VITE_", shared: "" },
+  expo: { server: "", client: "EXPO_PUBLIC_", shared: "" },
+  nuxt: { server: "", client: "NUXT_PUBLIC_", shared: "" },
+  sveltekit: { server: "", client: "PUBLIC_", shared: "" },
+  astro: { server: "", client: "PUBLIC_", shared: "" }
+};
+async function runCli(argv, io = {}) {
+  const runtimeIO = {
+    cwd: io.cwd ?? DEFAULT_IO.cwd,
+    stdout: io.stdout ?? DEFAULT_IO.stdout,
+    stderr: io.stderr ?? DEFAULT_IO.stderr
+  };
+  try {
+    if (argv.length === 0 || argv[0] === "--help" || argv[0] === "-h") {
+      runtimeIO.stdout(getRootHelpText());
+      return 0;
+    }
+    if (argv[0] !== "add") {
+      throw new Error(`Unknown command "${argv[0]}".
+${getRootHelpText()}`);
+    }
+    const subcommand = argv[1];
+    if (!subcommand || subcommand === "--help") {
+      runtimeIO.stdout(getAddHelpText());
+      return 0;
+    }
+    if (subcommand === "env") {
+      const options = parseAddEnvOptions(argv.slice(2));
+      if (options.help) {
+        runtimeIO.stdout(getAddEnvHelpText());
+        return 0;
+      }
+      await runAddEnv(options, runtimeIO);
+      return 0;
+    }
+    if (subcommand === "example") {
+      const options = parseAddExampleOptions(argv.slice(2));
+      if (options.help) {
+        runtimeIO.stdout(getAddExampleHelpText());
+        return 0;
+      }
+      await runAddExample(options, runtimeIO);
+      return 0;
+    }
+    throw new Error(`Unknown subcommand "add ${subcommand}".
+${getAddHelpText()}`);
+  } catch (error) {
+    runtimeIO.stderr(`${formatErrorMessage(error)}
+`);
+    return 1;
+  }
+}
+async function runAddEnv(options, io) {
+  const cwd = io.cwd();
+  const inputPath = resolveFromCwd(cwd, options.input ?? ".env.example");
+  const outputPath = resolveFromCwd(cwd, options.output ?? await getDefaultEnvOutputPath(cwd));
+  const source = await readTextFileOrThrow(inputPath, "input file");
+  const dotenv = decodeDotenvText(source);
+  const prefix = resolvePrefix(options);
+  const inferred = inferModel(dotenv, { prefix });
+  const generated = generateEnvTs(inferred);
+  await ensureWritableTarget(outputPath, options.force);
+  await writeFileAtomic(outputPath, generated);
+  io.stdout(`Generated ${outputPath}
+`);
+}
+async function runAddExample(options, io) {
+  const cwd = io.cwd();
+  const defaultInput = await getDefaultExampleInputPath(cwd);
+  const inputPath = resolveFromCwd(cwd, options.input ?? defaultInput);
+  const outputPath = resolveFromCwd(cwd, options.output ?? ".env.example");
+  const source = await readTextFileOrThrow(inputPath, "input env.ts");
+  const manifest = decodeManifestFromSource(source);
+  const generated = generateExample(manifest);
+  await ensureWritableTarget(outputPath, options.force);
+  await writeFileAtomic(outputPath, generated);
+  io.stdout(`Generated ${outputPath}
+`);
+}
+function resolvePrefix(options) {
+  const fromFramework = options.framework ? FRAMEWORK_PREFIXES[options.framework] : undefined;
+  return {
+    server: options.serverPrefix ?? fromFramework?.server ?? "",
+    client: options.clientPrefix ?? fromFramework?.client ?? "",
+    shared: options.sharedPrefix ?? fromFramework?.shared ?? ""
+  };
+}
+function parseFlags(args, spec) {
+  const parsed = {};
+  for (let index = 0;index < args.length; index += 1) {
+    const token = args[index];
+    if (!token.startsWith("--")) {
+      throw new Error(`Unexpected argument "${token}"`);
+    }
+    const [nameWithPrefix, inlineValue] = token.split("=", 2);
+    const name = nameWithPrefix.slice(2);
+    const expected = spec[name];
+    if (!expected) {
+      throw new Error(`Unknown option "--${name}"`);
+    }
+    if (expected === "boolean") {
+      if (inlineValue !== undefined) {
+        parsed[name] = inlineValue !== "false";
+      } else {
+        parsed[name] = true;
+      }
+      continue;
+    }
+    if (inlineValue !== undefined) {
+      parsed[name] = inlineValue;
+      continue;
+    }
+    const next = args[index + 1];
+    if (!next || next.startsWith("--")) {
+      throw new Error(`Option "--${name}" requires a value`);
+    }
+    parsed[name] = next;
+    index += 1;
+  }
+  return parsed;
+}
+function parseAddEnvOptions(args) {
+  const parsed = parseFlags(args, {
+    input: "string",
+    output: "string",
+    framework: "string",
+    "client-prefix": "string",
+    "server-prefix": "string",
+    "shared-prefix": "string",
+    force: "boolean",
+    help: "boolean"
+  });
+  const frameworkValue = parsed.framework;
+  if (frameworkValue !== undefined) {
+    if (typeof frameworkValue !== "string" || !FRAMEWORKS.includes(frameworkValue)) {
+      throw new Error(`Invalid value for --framework. Expected one of: ${FRAMEWORKS.join(", ")}.`);
+    }
+  }
+  return {
+    input: asOptionalString(parsed.input),
+    output: asOptionalString(parsed.output),
+    framework: frameworkValue,
+    clientPrefix: asOptionalString(parsed["client-prefix"]),
+    serverPrefix: asOptionalString(parsed["server-prefix"]),
+    sharedPrefix: asOptionalString(parsed["shared-prefix"]),
+    force: Boolean(parsed.force),
+    help: Boolean(parsed.help)
+  };
+}
+function parseAddExampleOptions(args) {
+  const parsed = parseFlags(args, {
+    input: "string",
+    output: "string",
+    force: "boolean",
+    help: "boolean"
+  });
+  return {
+    input: asOptionalString(parsed.input),
+    output: asOptionalString(parsed.output),
+    force: Boolean(parsed.force),
+    help: Boolean(parsed.help)
+  };
+}
+function asOptionalString(value) {
+  return typeof value === "string" ? value : undefined;
+}
+function getRootHelpText() {
+  return [
+    "Usage:",
+    "  envil add env [options]",
+    "  envil add example [options]",
+    "",
+    getAddHelpText().trimEnd(),
+    ""
+  ].join(`
+`);
+}
+function getAddHelpText() {
+  return [
+    "Subcommands:",
+    "  envil add env      Infer env.ts from .env.example",
+    "  envil add example  Recreate .env.example from env.ts manifest",
+    "",
+    "Use --help on each subcommand for details.",
+    ""
+  ].join(`
+`);
+}
+function getAddEnvHelpText() {
+  return [
+    "Usage:",
+    "  envil add env [options]",
+    "",
+    "Options:",
+    "  --input <path>           Input .env.example path (default: .env.example)",
+    "  --output <path>          Output env.ts path (default: src/env.ts or env.ts)",
+    "  --framework <name>       Prefix preset: nextjs|vite|expo|nuxt|sveltekit|astro",
+    "  --client-prefix <value>  Client runtime prefix override",
+    "  --server-prefix <value>  Server runtime prefix override",
+    "  --shared-prefix <value>  Shared runtime prefix override",
+    "  --force                  Overwrite output file if it exists",
+    "  --help                   Show this help text",
+    ""
+  ].join(`
+`);
+}
+function getAddExampleHelpText() {
+  return [
+    "Usage:",
+    "  envil add example [options]",
+    "",
+    "Options:",
+    "  --input <path>   Input env.ts path (default: env.ts, then src/env.ts fallback)",
+    "  --output <path>  Output .env.example path (default: .env.example)",
+    "  --force          Overwrite output file if it exists",
+    "  --help           Show this help text",
+    ""
+  ].join(`
+`);
+}
+function formatErrorMessage(error) {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return String(error);
+}
+if (import.meta.main) {
+  const exitCode = await runCli(process.argv.slice(2));
+  process.exit(exitCode);
+}
+export {
+  runCli
+};
+
+//# debugId=B3DBC46CBE56A44864756E2164756E21
+//# sourceMappingURL=cli.js.map