ultraenv 1.0.0

package/dist/declaration-LEME4AFZ.js

@@ -0,0 +1,10 @@
+import {
+  generateDeclaration,
+  generateDeclarationContent
+} from "./chunk-IGFVP24Q.js";
+import "./chunk-3VYXPTYV.js";
+import "./chunk-5G2DU52U.js";
+export {
+  generateDeclaration,
+  generateDeclarationContent
+};

package/dist/doctor-FZAUPKHS.js

@@ -0,0 +1,129 @@
+import {
+  drawTable
+} from "./chunk-WMHN5RW2.js";
+import {
+  isGitRepository
+} from "./chunk-R7PZRSZ7.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/doctor.ts
+import { resolve, join } from "path";
+async function run(args, ctx) {
+  try {
+    const cwd = args.flags["--cwd"] ?? ctx.cwd;
+    const baseDir = resolve(cwd);
+    writeLine(bold("\u{1F3E5} ultraenv Doctor"));
+    writeLine("");
+    writeLine(cyan("  Running self-checks..."));
+    writeLine("");
+    const checks = [];
+    const nodeVersion = process.version;
+    const major = parseInt(nodeVersion.slice(1), 10);
+    checks.push({
+      name: "Node.js version",
+      status: major >= 18 ? "pass" : "warn",
+      message: nodeVersion + (major >= 18 ? "" : " (recommended: >= 18)")
+    });
+    checks.push({
+      name: "Platform",
+      status: "pass",
+      message: `${process.platform} ${process.arch}`
+    });
+    const isGit = await isGitRepository(baseDir);
+    checks.push({
+      name: "Git repository",
+      status: isGit ? "pass" : "warn",
+      message: isGit ? "Detected" : "Not a git repository"
+    });
+    const envExists = await exists(join(baseDir, ".env"));
+    checks.push({
+      name: ".env file",
+      status: envExists ? "pass" : "warn",
+      message: envExists ? "Found" : "Not found"
+    });
+    const gitignoreExists = await exists(join(baseDir, ".gitignore"));
+    checks.push({
+      name: ".gitignore",
+      status: gitignoreExists ? "pass" : "warn",
+      message: gitignoreExists ? "Found" : "Not found"
+    });
+    const vaultExists = await exists(join(baseDir, ".env.vault"));
+    checks.push({
+      name: ".env.vault",
+      status: vaultExists ? "pass" : "warn",
+      message: vaultExists ? "Found" : "Not initialized"
+    });
+    const keysExists = await exists(join(baseDir, ".env.keys"));
+    if (vaultExists) {
+      checks.push({
+        name: ".env.keys",
+        status: keysExists ? "pass" : "fail",
+        message: keysExists ? "Found" : "Missing (vault needs keys)"
+      });
+    }
+    const exampleExists = await exists(join(baseDir, ".env.example"));
+    checks.push({
+      name: ".env.example",
+      status: exampleExists ? "pass" : "warn",
+      message: exampleExists ? "Found" : "Not found"
+    });
+    const { findConfig } = await import("./config-O5YRQP5Z.js");
+    const configPath = findConfig(baseDir);
+    checks.push({
+      name: "Configuration",
+      status: configPath ? "pass" : "warn",
+      message: configPath ?? "Not found (using defaults)"
+    });
+    const tsconfigExists = await exists(join(baseDir, "tsconfig.json"));
+    checks.push({
+      name: "TypeScript",
+      status: tsconfigExists ? "pass" : "warn",
+      message: tsconfigExists ? "tsconfig.json found" : "Not a TypeScript project"
+    });
+    const headers = ["Check", "Status", "Details"];
+    const rows = checks.map((check) => {
+      const statusIcon = check.status === "pass" ? green("\u2713") : check.status === "warn" ? yellow("\u26A0") : red("\u2717");
+      return [check.name, statusIcon, check.message];
+    });
+    writeLine(drawTable(headers, rows, { maxWidth: 90 }));
+    writeLine("");
+    const passed = checks.filter((c) => c.status === "pass").length;
+    const warnings = checks.filter((c) => c.status === "warn").length;
+    const failed = checks.filter((c) => c.status === "fail").length;
+    if (ctx.outputFormat === "json") {
+      writeJson({ checks, summary: { passed, warnings, failed, total: checks.length } });
+      return failed > 0 ? 1 : 0;
+    }
+    writeLine(cyan(`  ${passed}/${checks.length} passed, ${warnings} warning(s), ${failed} failure(s)`));
+    writeLine("");
+    if (failed > 0) {
+      writeLine(red(bold("  Some checks failed. Fix the issues above.")));
+      return 1;
+    }
+    writeLine(green(bold("  \u2705 ultraenv is healthy!")));
+    writeLine("");
+    return 0;
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    writeError(red(`  Doctor error: ${msg}`));
+    return 1;
+  }
+}
+export {
+  run
+};

package/dist/envs-compare-5K3HESX5.js

@@ -0,0 +1,49 @@
+import {
+  compareEnvironments,
+  formatComparison
+} from "./chunk-3UV2QNJL.js";
+import "./chunk-TE7HPLA6.js";
+import "./chunk-HFXQGJY3.js";
+import {
+  bold,
+  red,
+  yellow
+} from "./chunk-OMAOROL4.js";
+import {
+  writeError,
+  writeLine
+} from "./chunk-YN2KGTCB.js";
+import "./chunk-3VYXPTYV.js";
+import "./chunk-5G2DU52U.js";
+
+// src/cli/commands/envs-compare.ts
+async function run(args, ctx) {
+  try {
+    const cwd = args.flags["--cwd"] ?? ctx.cwd;
+    const env1 = args.positional[0] ?? args.flags["--source"];
+    const env2 = args.positional[1] ?? args.flags["--target"];
+    if (!env1 || !env2) {
+      writeError(red("  Two environment names required."));
+      writeError(yellow("  Usage: ultraenv envs compare <env1> <env2>"));
+      return 1;
+    }
+    writeLine(bold(`\u{1F4CA} Comparing environments: ${env1} vs ${env2}`));
+    writeLine("");
+    const comparison = await compareEnvironments(env1, env2, cwd);
+    writeLine(formatComparison(comparison));
+    writeLine("");
+    if (comparison.warnings.length > 0) {
+      writeLine(yellow(`  \u26A0 ${comparison.warnings.length} warning(s) detected.`));
+      writeLine("");
+      return 1;
+    }
+    return 0;
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    writeError(red(`  Error: ${msg}`));
+    return 1;
+  }
+}
+export {
+  run
+};

package/dist/envs-create-2XXHXMGA.js

@@ -0,0 +1,58 @@
+import {
+  createEnvironment,
+  listTemplates
+} from "./chunk-AWN6ADV7.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-5G2DU52U.js";
+
+// src/cli/commands/envs-create.ts
+async function run(args, ctx) {
+  try {
+    const cwd = args.flags["--cwd"] ?? ctx.cwd;
+    const name = args.positional[0];
+    if (!name) {
+      writeError(red("  Environment name required."));
+      writeError(yellow("  Usage: ultraenv envs create <name> [options]"));
+      writeLine("");
+      writeLine(cyan("  Available templates:"));
+      for (const t of listTemplates()) {
+        writeLine(`    ${cyan(t.name.padEnd(12))} ${t.description}`);
+      }
+      writeLine("");
+      return 1;
+    }
+    const template = args.flags["--template"];
+    const copyFrom = args.flags["--copy"];
+    writeLine(bold(`\u{1F4DD} Creating environment "${name}"`));
+    writeLine("");
+    await createEnvironment(name, {
+      fromTemplate: template,
+      copyFrom,
+      cwd
+    });
+    writeLine(green(`  \u2713 Created .env.${name}`));
+    writeLine("");
+    writeLine(cyan("  Next: Edit .env." + name + " with your environment variables"));
+    writeLine("");
+    return 0;
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    writeError(red(`  Error: ${msg}`));
+    return 1;
+  }
+}
+export {
+  run
+};

package/dist/envs-list-NQM5252B.js

@@ -0,0 +1,59 @@
+import {
+  drawTable
+} from "./chunk-WMHN5RW2.js";
+import {
+  listEnvironments
+} from "./chunk-GC7RXHLA.js";
+import "./chunk-HFXQGJY3.js";
+import {
+  bold,
+  cyan,
+  red,
+  yellow
+} from "./chunk-OMAOROL4.js";
+import {
+  writeError,
+  writeJson,
+  writeLine
+} from "./chunk-YN2KGTCB.js";
+import "./chunk-3VYXPTYV.js";
+import "./chunk-5G2DU52U.js";
+
+// src/cli/commands/envs-list.ts
+async function run(args, ctx) {
+  try {
+    const cwd = args.flags["--cwd"] ?? ctx.cwd;
+    const environments = await listEnvironments(cwd);
+    if (ctx.outputFormat === "json") {
+      writeJson({ environments });
+      return 0;
+    }
+    writeLine(bold("\u{1F4CB} Environments"));
+    writeLine("");
+    const existing = environments.filter((e) => e.exists);
+    if (existing.length === 0) {
+      writeLine(yellow("  No environment files found."));
+      writeLine("  Create one with: ultraenv envs create <name>");
+      writeLine("");
+      return 0;
+    }
+    const headers = ["Name", "File", "Variables", "Size", "Modified"];
+    const rows = existing.map((env) => {
+      const size = env.fileSize > 1024 ? `${(env.fileSize / 1024).toFixed(1)} KB` : `${env.fileSize} B`;
+      const modified = env.lastModified ? env.lastModified.slice(0, 19).replace("T", " ") : "-";
+      return [env.name, env.fileName, String(env.variableCount), size, modified];
+    });
+    writeLine(drawTable(headers, rows, { maxWidth: 100 }));
+    writeLine("");
+    writeLine(cyan(`  ${existing.length} environment(s) found.`));
+    writeLine("");
+    return 0;
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    writeError(red(`  Error: ${msg}`));
+    return 1;
+  }
+}
+export {
+  run
+};

package/dist/envs-switch-6L2AQYID.js

@@ -0,0 +1,50 @@
+import {
+  getActiveEnvironment,
+  switchEnvironment
+} from "./chunk-GC7RXHLA.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-5G2DU52U.js";
+
+// src/cli/commands/envs-switch.ts
+async function run(args, ctx) {
+  try {
+    const cwd = args.flags["--cwd"] ?? ctx.cwd;
+    const name = args.positional[0];
+    if (!name) {
+      const current = await getActiveEnvironment(cwd);
+      writeLine(cyan(`  Current environment: ${bold(current)}`));
+      writeLine("");
+      return 0;
+    }
+    const previous = await getActiveEnvironment(cwd);
+    if (previous !== "base") {
+      writeLine(cyan(`  Switching from "${previous}" to "${name}"...`));
+    } else {
+      writeLine(cyan(`  Switching to "${name}"...`));
+    }
+    await switchEnvironment(name, cwd);
+    writeLine(green(bold(`  \u2705 Switched to "${name}"`)));
+    writeLine(yellow("  .env.local has been updated with the environment variables."));
+    writeLine("");
+    return 0;
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    writeError(red(`  Error: ${msg}`));
+    return 1;
+  }
+}
+export {
+  run
+};

package/dist/envs-validate-FL73Q76T.js

@@ -0,0 +1,89 @@
+import {
+  drawTable
+} from "./chunk-WMHN5RW2.js";
+import {
+  validateAllEnvironments
+} from "./chunk-GC7RXHLA.js";
+import "./chunk-HFXQGJY3.js";
+import {
+  bold,
+  green,
+  red,
+  yellow
+} from "./chunk-OMAOROL4.js";
+import {
+  writeError,
+  writeJson,
+  writeLine
+} from "./chunk-YN2KGTCB.js";
+import "./chunk-3VYXPTYV.js";
+import "./chunk-5G2DU52U.js";
+
+// src/cli/commands/envs-validate.ts
+async function run(args, ctx) {
+  try {
+    const cwd = args.flags["--cwd"] ?? ctx.cwd;
+    writeLine(bold("\u2705 Validating all environments"));
+    writeLine("");
+    const schema = ctx.config.schema;
+    if (!schema) {
+      writeLine(yellow("  No schema defined in configuration. Basic validation only."));
+      writeLine("");
+    }
+    const results = await validateAllEnvironments(
+      ctx.config.schema?.definitions ?? {},
+      cwd
+    );
+    if (ctx.outputFormat === "json") {
+      const jsonResults = {};
+      for (const [name, result] of results) {
+        jsonResults[name] = {
+          valid: result.valid,
+          errors: result.errors.map((e) => e.message),
+          warnings: result.warnings.map((w) => w.message)
+        };
+      }
+      writeJson({ environments: jsonResults });
+      return [...results.values()].every((r) => r.valid) ? 0 : 1;
+    }
+    const headers = ["Environment", "Status", "Errors", "Warnings"];
+    const rows = [];
+    for (const [name, result] of results) {
+      const status = result.valid ? green("\u2713 Pass") : red("\u2717 Fail");
+      rows.push([name, status, String(result.errors.length), String(result.warnings.length)]);
+    }
+    writeLine(drawTable(headers, rows, { maxWidth: 80 }));
+    writeLine("");
+    let hasErrors = false;
+    for (const [name, result] of results) {
+      if (!result.valid) {
+        hasErrors = true;
+        writeLine(red(`  ${name}:`));
+        for (const err of result.errors) {
+          writeLine(red(`    \u2717 ${err.message}`));
+          if (err.hint) {
+            writeLine(yellow(`      Hint: ${err.hint}`));
+          }
+        }
+        writeLine("");
+      }
+      if (result.warnings.length > 0) {
+        for (const warn of result.warnings) {
+          writeLine(yellow(`  ${name}: \u26A0 ${warn.message}`));
+        }
+      }
+    }
+    if (!hasErrors) {
+      writeLine(green(bold("  \u2705 All environments passed validation")));
+    }
+    writeLine("");
+    return hasErrors ? 1 : 0;
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    writeError(red(`  Error: ${msg}`));
+    return 1;
+  }
+}
+export {
+  run
+};

package/dist/fs-VH7ATUS3.js

@@ -0,0 +1,31 @@
+import {
+  copyFile,
+  ensureDir,
+  exists,
+  existsSyncCheck,
+  findUp,
+  findUpSync,
+  isDirectory,
+  isFile,
+  listFiles,
+  readFile,
+  readFileSync,
+  removeFile,
+  writeFile
+} from "./chunk-3VYXPTYV.js";
+import "./chunk-5G2DU52U.js";
+export {
+  copyFile,
+  ensureDir,
+  exists,
+  existsSyncCheck,
+  findUp,
+  findUpSync,
+  isDirectory,
+  isFile,
+  listFiles,
+  readFile,
+  readFileSync,
+  removeFile,
+  writeFile
+};

package/dist/generator-LFZBMZZS.js

@@ -0,0 +1,14 @@
+import {
+  generateExampleContent,
+  generateExampleFile,
+  needsUpdate
+} from "./chunk-CHVO6NWI.js";
+import "./chunk-TE7HPLA6.js";
+import "./chunk-HFXQGJY3.js";
+import "./chunk-3VYXPTYV.js";
+import "./chunk-5G2DU52U.js";
+export {
+  generateExampleContent,
+  generateExampleFile,
+  needsUpdate
+};

package/dist/git-BZS4DPAI.js

@@ -0,0 +1,30 @@
+import {
+  getCommitHash,
+  getConfig,
+  getConfigAll,
+  getCurrentBranch,
+  getDiffFiles,
+  getFullCommitHash,
+  getGitRoot,
+  getRemoteUrl,
+  getStagedFiles,
+  getTrackedFiles,
+  isDirty,
+  isGitIgnored,
+  isGitRepository
+} from "./chunk-R7PZRSZ7.js";
+export {
+  getCommitHash,
+  getConfig,
+  getConfigAll,
+  getCurrentBranch,
+  getDiffFiles,
+  getFullCommitHash,
+  getGitRoot,
+  getRemoteUrl,
+  getStagedFiles,
+  getTrackedFiles,
+  isDirty,
+  isGitIgnored,
+  isGitRepository
+};

package/dist/help-3XJBXEHE.js

@@ -0,0 +1,121 @@
+import {
+  bold,
+  cyan,
+  dim
+} from "./chunk-OMAOROL4.js";
+import {
+  writeError,
+  writeLine
+} from "./chunk-YN2KGTCB.js";
+import {
+  VERSION
+} from "./chunk-XC65ORJ5.js";
+
+// src/cli/commands/help.ts
+var COMMANDS = [
+  { name: "init", description: "Initialize ultraenv in a project", usage: "ultraenv init [options]" },
+  { name: "validate", description: "Validate environment against schema", usage: "ultraenv validate [options]" },
+  { name: "typegen", description: "Generate TypeScript types", usage: "ultraenv typegen [options]" },
+  { name: "sync", description: "Sync .env.example", usage: "ultraenv sync [options]" },
+  { name: "scan", description: "Scan for leaked secrets", usage: "ultraenv scan [options]" },
+  { name: "debug", description: "Show environment diagnostics", usage: "ultraenv debug [options]" },
+  { name: "protect", description: "Verify .gitignore protection", usage: "ultraenv protect [options]" },
+  { name: "vault init", description: "Initialize encrypted vault", usage: "ultraenv vault init [options]" },
+  { name: "vault encrypt", description: "Encrypt .env \u2192 vault", usage: "ultraenv vault encrypt [options]" },
+  { name: "vault decrypt", description: "Decrypt vault \u2192 .env", usage: "ultraenv vault decrypt [options]" },
+  { name: "vault rekey", description: "Rotate encryption keys", usage: "ultraenv vault rekey [options]" },
+  { name: "vault status", description: "Show vault status", usage: "ultraenv vault status [options]" },
+  { name: "vault diff", description: "Compare .env vs vault", usage: "ultraenv vault diff [options]" },
+  { name: "vault verify", description: "Verify vault integrity", usage: "ultraenv vault verify [options]" },
+  { name: "envs list", description: "List all environments", usage: "ultraenv envs list [options]" },
+  { name: "envs compare", description: "Compare two environments", usage: "ultraenv envs compare <env1> <env2>" },
+  { name: "envs validate", description: "Validate all environments", usage: "ultraenv envs validate [options]" },
+  { name: "envs create", description: "Create new environment", usage: "ultraenv envs create <name> [options]" },
+  { name: "envs switch", description: "Switch current environment", usage: "ultraenv envs switch <name>" },
+  { name: "ci validate", description: "CI validation mode", usage: "ultraenv ci validate [options]" },
+  { name: "ci check-sync", description: "CI sync check", usage: "ultraenv ci check-sync [options]" },
+  { name: "ci scan", description: "CI secret scan", usage: "ultraenv ci scan [options]" },
+  { name: "ci setup", description: "Generate CI config", usage: "ultraenv ci setup [options]" },
+  { name: "install-hook", description: "Install git pre-commit hook", usage: "ultraenv install-hook [options]" },
+  { name: "doctor", description: "Self-check installation", usage: "ultraenv doctor [options]" },
+  { name: "completion", description: "Generate shell completions", usage: "ultraenv completion <shell>" },
+  { name: "version", description: "Show version", usage: "ultraenv version" }
+];
+async function run(args, _ctx) {
+  const topic = args.positional[0];
+  if (topic) {
+    const cmd = COMMANDS.find((c) => c.name === topic || c.name.startsWith(topic));
+    if (cmd) {
+      writeLine("");
+      writeLine(bold(`  ${cmd.description}`));
+      writeLine("");
+      writeLine(`  Usage: ${cmd.usage}`);
+      writeLine("");
+      const optionsMap = {
+        "init": ["--force", "--cwd <path>"],
+        "validate": ["--env-dir <path>", "--quiet"],
+        "typegen": ["--format <type>", "--out <path>", "--interface <name>"],
+        "sync": ["--mode <mode>", "--file <path>", "--out <path>", "--watch"],
+        "scan": ["--scope <scope>", "--format <type>", "--include <glob>", "--exclude <glob>"],
+        "vault init": ["--env <name>", "--force", "--key <key>"],
+        "vault encrypt": ["--env <name>", "--key <key>"],
+        "vault decrypt": ["--env <name>", "--key <key>"],
+        "envs create": ["--template <name>", "--copy <name>"],
+        "ci scan": ["--format <type>", "--git-history", "--fail-fast"]
+      };
+      const opts = optionsMap[cmd.name];
+      if (opts) {
+        writeLine("  Options:");
+        for (const opt of opts) {
+          writeLine(`    ${cyan(opt)}`);
+        }
+        writeLine("");
+      }
+      return 0;
+    }
+    writeError(`  Unknown command: ${topic}`);
+    writeLine("");
+  }
+  writeLine("");
+  writeLine(bold("  ultraenv \u2014 The Ultimate Environment Variable Manager"));
+  writeLine(`  ${dim(`v${VERSION}`)}`);
+  writeLine("");
+  writeLine("  USAGE:");
+  writeLine("    ultraenv <command> [options] [arguments]");
+  writeLine("");
+  writeLine("  COMMANDS:");
+  writeLine("");
+  const core = COMMANDS.filter((c) => !c.name.startsWith("vault") && !c.name.startsWith("envs") && !c.name.startsWith("ci"));
+  const vault = COMMANDS.filter((c) => c.name.startsWith("vault"));
+  const envs = COMMANDS.filter((c) => c.name.startsWith("envs"));
+  const ci = COMMANDS.filter((c) => c.name.startsWith("ci"));
+  const printGroup = (title, cmds) => {
+    writeLine(`  ${bold(title)}`);
+    for (const cmd of cmds) {
+      const paddedName = cmd.name.padEnd(20);
+      writeLine(`    ${cyan(paddedName)} ${cmd.description}`);
+    }
+    writeLine("");
+  };
+  printGroup("Core:", core);
+  printGroup("Vault:", vault);
+  printGroup("Environments:", envs);
+  printGroup("CI/CD:", ci);
+  writeLine("  GLOBAL OPTIONS:");
+  writeLine("");
+  writeLine("    --help, -h          Show help for a command");
+  writeLine("    --version           Show version");
+  writeLine("    --no-color          Disable colored output");
+  writeLine("    --verbose, -v       Verbose output");
+  writeLine("    --quiet, -q         Suppress output");
+  writeLine("    --strict            Strict mode");
+  writeLine("    --debug             Debug logging");
+  writeLine("    --cwd <path>        Working directory");
+  writeLine("    --config <path>     Config file");
+  writeLine("    --format <type>     Output: terminal|json|silent");
+  writeLine("");
+  return 0;
+}
+export {
+  run
+};