ultraenv 1.0.0

package/dist/schema/index.js

@@ -0,0 +1,152 @@
+import {
+  ArraySchemaBuilder,
+  BigIntSchemaBuilder,
+  BooleanSchemaBuilder,
+  DateSchemaBuilder,
+  EnumSchemaBuilder,
+  JsonSchemaBuilder,
+  NumberSchemaBuilder,
+  RegexSchemaBuilder,
+  SchemaBuilder,
+  StringSchemaBuilder,
+  allOf,
+  applyAlias,
+  applyConditional,
+  applyCustom,
+  applyDefault,
+  applyDeprecated,
+  applyDescription,
+  applyOptional,
+  applyRequired,
+  applySecret,
+  applyTransform,
+  check,
+  composeTransforms,
+  createArraySchema,
+  createBase64Schema,
+  createBigIntSchema,
+  createBooleanSchema,
+  createBytesSchema,
+  createColorSchema,
+  createCountrySchema,
+  createCronSchema,
+  createCurrencySchema,
+  createDateSchema,
+  createDurationSchema,
+  createEmailSchema,
+  createEnumSchema,
+  createHexSchema,
+  createHostnameSchema,
+  createIpSchema,
+  createIpv4Schema,
+  createIpv6Schema,
+  createJsonSchema,
+  createLocaleSchema,
+  createNumberSchema,
+  createPathSchema,
+  createPortSchema,
+  createRegexSchema,
+  createSemverSchema,
+  createStringSchema,
+  createTimezoneSchema,
+  createUrlSchema,
+  createUuidSchema,
+  defineEnv,
+  formatSchemaDescription,
+  formatValidationResult,
+  getAliases,
+  getDefaultValue,
+  getDeprecationMessage,
+  getDescription,
+  hasConditional,
+  hasDefault,
+  isAlias,
+  isDeprecated,
+  isOptional,
+  isRequired,
+  isSecret,
+  maskValue,
+  maxLength,
+  minLength,
+  shouldApply,
+  t,
+  tryDefineEnv,
+  validate,
+  validateValue
+} from "../chunk-CIFMBJ4H.js";
+export {
+  ArraySchemaBuilder,
+  BigIntSchemaBuilder,
+  BooleanSchemaBuilder,
+  DateSchemaBuilder,
+  EnumSchemaBuilder,
+  JsonSchemaBuilder,
+  NumberSchemaBuilder,
+  RegexSchemaBuilder,
+  SchemaBuilder,
+  StringSchemaBuilder,
+  allOf,
+  applyAlias,
+  applyConditional,
+  applyCustom,
+  applyDefault,
+  applyDeprecated,
+  applyDescription,
+  applyOptional,
+  applyRequired,
+  applySecret,
+  applyTransform,
+  check,
+  composeTransforms,
+  createArraySchema,
+  createBase64Schema,
+  createBigIntSchema,
+  createBooleanSchema,
+  createBytesSchema,
+  createColorSchema,
+  createCountrySchema,
+  createCronSchema,
+  createCurrencySchema,
+  createDateSchema,
+  createDurationSchema,
+  createEmailSchema,
+  createEnumSchema,
+  createHexSchema,
+  createHostnameSchema,
+  createIpSchema,
+  createIpv4Schema,
+  createIpv6Schema,
+  createJsonSchema,
+  createLocaleSchema,
+  createNumberSchema,
+  createPathSchema,
+  createPortSchema,
+  createRegexSchema,
+  createSemverSchema,
+  createStringSchema,
+  createTimezoneSchema,
+  createUrlSchema,
+  createUuidSchema,
+  maxLength as customMaxLength,
+  minLength as customMinLength,
+  defineEnv,
+  formatSchemaDescription,
+  formatValidationResult,
+  getAliases,
+  getDeprecationMessage,
+  getDescription,
+  getDefaultValue as getModDefault,
+  hasConditional,
+  hasDefault,
+  isAlias,
+  isDeprecated,
+  isOptional,
+  isRequired,
+  isSecret,
+  maskValue,
+  shouldApply,
+  t,
+  tryDefineEnv,
+  validate,
+  validateValue
+};

package/dist/sync-TMHMTLH2.js

@@ -0,0 +1,186 @@
+import {
+  drawBox
+} from "./chunk-TMT5KCO3.js";
+import {
+  bold,
+  cyan,
+  green,
+  red,
+  yellow
+} from "./chunk-OMAOROL4.js";
+import {
+  writeError,
+  writeJson,
+  writeLine
+} from "./chunk-YN2KGTCB.js";
+import {
+  exists
+} from "./chunk-3VYXPTYV.js";
+import "./chunk-5G2DU52U.js";
+
+// src/cli/commands/sync.ts
+import { resolve, join } from "path";
+import { watch } from "fs";
+async function run(args, ctx) {
+  try {
+    const cwd = args.flags["--cwd"] ?? ctx.cwd;
+    const baseDir = resolve(cwd);
+    const envPath = args.flags["--file"] ?? join(baseDir, ".env");
+    const examplePath = args.flags["--out"] ?? join(baseDir, ".env.example");
+    const mode = args.flags["--mode"] ?? "check";
+    if (mode === "check") {
+      return await checkSync(envPath, examplePath, ctx);
+    }
+    if (mode === "generate") {
+      return await generateSync(envPath, examplePath);
+    }
+    if (mode === "interactive") {
+      return await interactiveSync(envPath, examplePath);
+    }
+    if (mode === "watch") {
+      return await watchSync(envPath, examplePath);
+    }
+    writeError(red(`  Unknown sync mode: ${mode}`));
+    writeError(yellow("  Available modes: generate, check, interactive, watch"));
+    return 1;
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    writeError(red(`  Sync error: ${msg}`));
+    return 1;
+  }
+}
+async function checkSync(envPath, examplePath, ctx) {
+  const envExists = await exists(envPath);
+  const exampleExists = await exists(examplePath);
+  if (!envExists) {
+    if (ctx.outputFormat === "json") {
+      writeJson({ inSync: false, error: ".env file not found" });
+    } else {
+      writeError(yellow('  \u26A0 .env file not found. Run "ultraenv sync --mode generate" to create .env.example.'));
+    }
+    return 1;
+  }
+  if (!exampleExists) {
+    if (ctx.outputFormat === "json") {
+      writeJson({ inSync: false, error: ".env.example not found" });
+    } else {
+      writeError(yellow('  \u26A0 .env.example not found. Run "ultraenv sync --mode generate" to create it.'));
+    }
+    return 1;
+  }
+  const { compareSync, formatSyncDiff } = await import("./comparator-RDKX3OI7.js");
+  const diff = await compareSync(envPath, examplePath);
+  if (ctx.outputFormat === "json") {
+    writeJson({
+      inSync: diff.inSync,
+      missing: diff.missing,
+      extra: diff.extra,
+      different: diff.different,
+      same: diff.same
+    });
+    return diff.inSync ? 0 : 1;
+  }
+  writeLine(bold("\u{1F504} .env Sync Check"));
+  writeLine("");
+  writeLine(formatSyncDiff(diff));
+  writeLine("");
+  if (!diff.inSync) {
+    const box = drawBox([
+      "Your .env is out of sync with .env.example.",
+      'Run "ultraenv sync --mode generate" to update .env.example',
+      'or "ultraenv sync --mode interactive" to review changes.'
+    ], { title: "ACTION NEEDED", border: "rounded" });
+    writeLine(box);
+    writeLine("");
+    return 1;
+  }
+  writeLine(green(bold("  \u2705 .env is in sync with .env.example")));
+  writeLine("");
+  return 0;
+}
+async function generateSync(envPath, examplePath) {
+  const envExists = await exists(envPath);
+  if (!envExists) {
+    writeError(yellow("  \u26A0 .env file not found. Create a .env file first."));
+    return 1;
+  }
+  const { generateExampleFile } = await import("./generator-LFZBMZZS.js");
+  await generateExampleFile(envPath, examplePath, {
+    includeDescriptions: true,
+    includeTypes: true,
+    includeDefaults: true
+  });
+  writeLine(bold("\u{1F4DD} Generating .env.example..."));
+  writeLine("");
+  writeLine(green(`  \u2713 Generated ${examplePath}`));
+  writeLine("");
+  return 0;
+}
+async function interactiveSync(envPath, examplePath) {
+  const { compareSync } = await import("./comparator-RDKX3OI7.js");
+  const envExists = await exists(envPath);
+  if (!envExists) {
+    writeError(yellow("  \u26A0 .env file not found."));
+    return 1;
+  }
+  const diff = await compareSync(envPath, examplePath);
+  if (diff.inSync) {
+    writeLine(green("  \u2713 Already in sync."));
+    return 0;
+  }
+  writeLine(bold("\u{1F4CB} Differences found:"));
+  writeLine("");
+  if (diff.missing.length > 0) {
+    writeLine(yellow("  Missing in .env:"));
+    for (const key of diff.missing) {
+      writeLine(`    - ${key}`);
+    }
+    writeLine("");
+  }
+  if (diff.extra.length > 0) {
+    writeLine(yellow("  Extra in .env (not in .env.example):"));
+    for (const key of diff.extra) {
+      writeLine(`    + ${key}`);
+    }
+    writeLine("");
+  }
+  const { generateExampleFile } = await import("./generator-LFZBMZZS.js");
+  await generateExampleFile(envPath, examplePath);
+  writeLine(green(`  \u2713 Updated ${examplePath}`));
+  writeLine("");
+  return 0;
+}
+async function watchSync(envPath, examplePath) {
+  const { generateExampleFile } = await import("./generator-LFZBMZZS.js");
+  writeLine(bold("\u{1F441}\uFE0F  Watching for .env changes..."));
+  writeLine(cyan("  Press Ctrl+C to stop."));
+  writeLine("");
+  await generateExampleFile(envPath, examplePath);
+  writeLine(green(`  \u2713 Generated ${examplePath}`));
+  return new Promise((resolvePromise) => {
+    let debounceTimer = null;
+    let watcher = null;
+    watcher = watch(envPath, (eventType) => {
+      if (eventType !== "change") return;
+      if (debounceTimer !== null) clearTimeout(debounceTimer);
+      debounceTimer = setTimeout(async () => {
+        try {
+          await generateExampleFile(envPath, examplePath);
+          writeLine(green(`  \u2713 Updated ${examplePath} (${(/* @__PURE__ */ new Date()).toLocaleTimeString()})`));
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err);
+          writeError(red(`  \u2717 Failed to update: ${msg}`));
+        }
+      }, 200);
+    });
+    process.on("SIGINT", () => {
+      if (watcher !== null) watcher.close();
+      writeLine("");
+      writeLine(cyan("  Watcher stopped."));
+      resolvePromise(0);
+    });
+  });
+}
+export {
+  run
+};

package/dist/typegen-SQOSXBWM.js

@@ -0,0 +1,80 @@
+import {
+  loadWithResult
+} from "./chunk-MNVFG7H4.js";
+import "./chunk-HFXQGJY3.js";
+import {
+  bold,
+  cyan,
+  green,
+  red,
+  yellow
+} from "./chunk-OMAOROL4.js";
+import {
+  writeError,
+  writeLine
+} from "./chunk-YN2KGTCB.js";
+import "./chunk-3VYXPTYV.js";
+import "./chunk-XC65ORJ5.js";
+import "./chunk-5G2DU52U.js";
+
+// src/cli/commands/typegen.ts
+import { resolve } from "path";
+async function run(args, ctx) {
+  try {
+    const cwd = args.flags["--cwd"] ?? ctx.cwd;
+    const envDir = resolve(cwd);
+    const format = args.flags["--format"] ?? "declaration";
+    const outFlag = args.flags["--out"];
+    const defaultOutPaths = {
+      "declaration": "src/env.d.ts",
+      "module": "src/env.ts",
+      "json-schema": "env.schema.json"
+    };
+    const outputPath = outFlag ? resolve(cwd, outFlag) : resolve(cwd, defaultOutPaths[format] ?? "src/env.d.ts");
+    const interfaceName = args.flags["--interface"] ?? "Env";
+    const result = loadWithResult({ envDir, overrideProcessEnv: false });
+    writeLine(bold(`\u{1F4DD} Generating ${format} types...`));
+    writeLine("");
+    const schema = ctx.config.schema?.definitions;
+    let content = "";
+    if (format === "declaration") {
+      const { generateDeclarationContent } = await import("./declaration-LEME4AFZ.js");
+      content = generateDeclarationContent(
+        result.env,
+        schema,
+        { interfaceName, jsdoc: true, indent: 4 }
+      );
+    } else if (format === "module") {
+      const { generateModuleContent } = await import("./module-IDIZPP4M.js");
+      if (!schema) {
+        writeError(yellow("  Warning: No schema defined. Generating empty module."));
+        writeError(yellow("  Add a schema to your .ultraenvrc.json for typed output."));
+      }
+      content = generateModuleContent(
+        schema ?? {},
+        { interfaceName, jsdoc: true, indent: 2 }
+      );
+    } else if (format === "json-schema") {
+      const { generateJsonSchemaContent } = await import("./json-schema-I26YNQBH.js");
+      content = generateJsonSchemaContent(
+        schema ?? {},
+        { includeDescriptions: true, indent: 2 }
+      );
+    }
+    const { writeFile, ensureDir } = await import("./fs-VH7ATUS3.js");
+    await ensureDir(resolve(outputPath, ".."));
+    await writeFile(outputPath, content);
+    writeLine(green(`  \u2713 Generated ${format} types`));
+    writeLine(cyan(`  Output: ${outputPath}`));
+    writeLine(cyan(`  Variables: ${Object.keys(result.env).length}`));
+    writeLine("");
+    return 0;
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    writeError(red(`  Type generation error: ${msg}`));
+    return 1;
+  }
+}
+export {
+  run
+};

package/dist/validate-IOAM5HWS.js

@@ -0,0 +1,100 @@
+import {
+  drawTable
+} from "./chunk-WMHN5RW2.js";
+import {
+  loadWithResult
+} from "./chunk-MNVFG7H4.js";
+import "./chunk-HFXQGJY3.js";
+import {
+  bold,
+  cyan,
+  green,
+  red,
+  yellow
+} from "./chunk-OMAOROL4.js";
+import {
+  writeError,
+  writeJson,
+  writeLine
+} from "./chunk-YN2KGTCB.js";
+import "./chunk-3VYXPTYV.js";
+import "./chunk-XC65ORJ5.js";
+import "./chunk-5G2DU52U.js";
+
+// src/cli/commands/validate.ts
+import { resolve } from "path";
+async function run(args, ctx) {
+  try {
+    const cwd = args.flags["--cwd"] ?? ctx.cwd;
+    const envDir = resolve(cwd);
+    const result = loadWithResult({
+      envDir,
+      expandVariables: ctx.config.expandVariables,
+      overrideProcessEnv: false,
+      mergeStrategy: ctx.config.mergeStrategy
+    });
+    if (ctx.outputFormat === "json") {
+      writeJson({
+        valid: true,
+        metadata: result.metadata,
+        variables: Object.keys(result.env).length,
+        env: result.env
+      });
+      return 0;
+    }
+    writeLine(bold("\u{1F50D} Environment Validation"));
+    writeLine("");
+    writeLine(cyan("  Files parsed: ") + `${result.metadata.filesParsed}`);
+    writeLine(cyan("  Total variables: ") + `${result.metadata.totalVars}`);
+    writeLine(cyan("  Load time: ") + `${result.metadata.loadTimeMs}ms`);
+    writeLine(cyan("  Had overrides: ") + `${result.metadata.hadOverrides ? "yes" : "no"}`);
+    writeLine("");
+    if (result.metadata.totalVars === 0) {
+      writeLine(yellow("  \u26A0 No environment variables found."));
+      writeLine(yellow("  Create a .env file in your project directory."));
+      return 1;
+    }
+    if (result.parsed.length > 0) {
+      writeLine(bold("  Loaded files:"));
+      for (const file of result.parsed) {
+        const status = file.exists ? green("\u2713") : red("\u2717");
+        const varCount = `${file.vars.length} var(s)`;
+        writeLine(`    ${status} ${file.path} (${varCount})`);
+      }
+      writeLine("");
+    }
+    const vars = Object.entries(result.env);
+    if (vars.length > 0 && !args.flags["--quiet"]) {
+      const maxShow = 50;
+      const shownVars = vars.slice(0, maxShow);
+      const headers = ["Variable", "Value", "Source"];
+      const rows = shownVars.map(([key, value]) => {
+        let source = "unknown";
+        for (const pf of result.parsed) {
+          const found = pf.vars.find((v) => v.key === key);
+          if (found) {
+            source = pf.path.replace(envDir + "/", "");
+            break;
+          }
+        }
+        const displayValue = value.length > 40 ? value.slice(0, 37) + "..." : value;
+        return [key, displayValue, source];
+      });
+      writeLine(drawTable(headers, rows, { maxWidth: 100 }));
+      if (vars.length > maxShow) {
+        writeLine(yellow(`  ... and ${vars.length - maxShow} more variables`));
+      }
+    }
+    writeLine("");
+    writeLine(green(bold("  \u2705 Environment validated successfully")));
+    writeLine("");
+    return 0;
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    writeError(red(`  Validation error: ${msg}`));
+    return 1;
+  }
+}
+export {
+  run
+};

package/dist/vault-decrypt-U6HJZNBV.js

@@ -0,0 +1,111 @@
+import {
+  readVaultFile
+} from "./chunk-NBOABPHM.js";
+import {
+  bold,
+  cyan,
+  green,
+  red,
+  yellow
+} from "./chunk-OMAOROL4.js";
+import {
+  writeError,
+  writeLine
+} from "./chunk-YN2KGTCB.js";
+import {
+  exists,
+  readFile
+} from "./chunk-3VYXPTYV.js";
+import {
+  parseKey
+} from "./chunk-UEWYFN6A.js";
+import {
+  decryptValue,
+  isEncryptedValue
+} from "./chunk-2USZPWLZ.js";
+import "./chunk-XC65ORJ5.js";
+import {
+  getErrorMessage
+} from "./chunk-5G2DU52U.js";
+
+// src/cli/commands/vault-decrypt.ts
+import { resolve, join } from "path";
+async function run(args, ctx) {
+  try {
+    const cwd = args.flags["--cwd"] ?? ctx.cwd;
+    const baseDir = resolve(cwd);
+    const envName = args.flags["--env"] ?? "production";
+    const keyInput = args.flags["--key"];
+    writeLine(bold(`\u{1F513} Decrypting vault \u2192 "${envName}" environment`));
+    writeLine("");
+    const vaultPath = join(baseDir, ".env.vault");
+    if (!await exists(vaultPath)) {
+      writeError(red("  .env.vault not found."));
+      return 1;
+    }
+    const vault = await readVaultFile(vaultPath);
+    const entry = vault.get(envName.toLowerCase());
+    if (!entry) {
+      writeError(red(`  Environment "${envName}" not found in vault.`));
+      writeError(yellow(`  Available: ${[...vault.keys()].join(", ") || "none"}`));
+      return 1;
+    }
+    let rawKey;
+    if (keyInput) {
+      rawKey = parseKey(keyInput);
+    } else {
+      const keysPath = join(baseDir, ".env.keys");
+      if (!await exists(keysPath)) {
+        writeError(red("  No encryption key provided and .env.keys not found."));
+        return 1;
+      }
+      const keysContent = await readFile(keysPath);
+      const { parseKeysFile } = await import("./key-manager-O3G55WPU.js");
+      const keys = parseKeysFile(keysContent);
+      const envKey = keys.get(envName.toLowerCase());
+      if (!envKey) {
+        writeError(red(`  No key found for environment "${envName}"`));
+        return 1;
+      }
+      rawKey = parseKey(envKey);
+    }
+    writeLine(cyan("  Decrypting variables..."));
+    const decryptedLines = [];
+    const encryptedContent = entry.encrypted;
+    for (const line of encryptedContent.split("\n")) {
+      const eqIdx = line.indexOf("=");
+      if (eqIdx === -1) {
+        decryptedLines.push(line);
+        continue;
+      }
+      const key = line.slice(0, eqIdx);
+      const value = line.slice(eqIdx + 1);
+      if (isEncryptedValue(value)) {
+        try {
+          const decrypted = decryptValue(value, rawKey);
+          decryptedLines.push(`${key}=${decrypted}`);
+        } catch {
+          writeError(yellow(`  \u26A0 Failed to decrypt "${key}" (wrong key?)`));
+          decryptedLines.push(`${key}=<DECRYPTION_FAILED>`);
+        }
+      } else {
+        decryptedLines.push(line);
+      }
+    }
+    const outputPath = join(baseDir, `.env.${envName}`);
+    const { writeFile } = await import("./fs-VH7ATUS3.js");
+    await writeFile(outputPath, decryptedLines.join("\n"));
+    writeLine(green(`  \u2713 Decrypted to ${outputPath}`));
+    writeLine(green(`  \u2713 Variables: ${entry.varCount}`));
+    writeLine("");
+    writeLine(green(bold("  \u2705 Decryption complete!")));
+    writeLine("");
+    return 0;
+  } catch (error) {
+    writeError(red(`  Decrypt error: ${getErrorMessage(error)}`));
+    return 1;
+  }
+}
+export {
+  run
+};