ultraenv 1.0.0

package/dist/chunk-GC7RXHLA.js

@@ -0,0 +1,253 @@
+import {
+  parseEnvFile
+} from "./chunk-HFXQGJY3.js";
+import {
+  exists,
+  listFiles,
+  readFile,
+  writeFile
+} from "./chunk-3VYXPTYV.js";
+import {
+  FileSystemError
+} from "./chunk-5G2DU52U.js";
+
+// src/environments/manager.ts
+import { resolve, join } from "path";
+import { statSync } from "fs";
+var KNOWN_ENVIRONMENTS = [
+  "development",
+  "staging",
+  "production",
+  "test"
+];
+var ENV_FILE_PATTERNS = [
+  ".env",
+  ".env.local",
+  ".env.development",
+  ".env.development.local",
+  ".env.staging",
+  ".env.staging.local",
+  ".env.production",
+  ".env.production.local",
+  ".env.test",
+  ".env.test.local",
+  ".env.ci"
+];
+function extractEnvName(fileName) {
+  if (fileName === ".env" || fileName === ".env.local") {
+    return null;
+  }
+  if (!fileName.startsWith(".env.")) {
+    return null;
+  }
+  let name = fileName.slice(5);
+  if (name.endsWith(".local")) {
+    name = name.slice(0, -6);
+    if (name === "") return null;
+  }
+  return name;
+}
+async function listEnvironments(cwd) {
+  const baseDir = resolve(cwd ?? process.cwd());
+  const environments = [];
+  for (const pattern of ENV_FILE_PATTERNS) {
+    const absolutePath = join(baseDir, pattern);
+    const fileExists = await exists(absolutePath);
+    const envName = extractEnvName(pattern);
+    let fileSize = 0;
+    let lastModified = "";
+    let variableCount = 0;
+    if (fileExists) {
+      try {
+        const stat = statSync(absolutePath);
+        fileSize = stat.size;
+        lastModified = stat.mtime.toISOString();
+      } catch {
+      }
+      try {
+        const content = await readFile(absolutePath);
+        const parsed = parseEnvFile(content, absolutePath);
+        variableCount = parsed.vars.length;
+      } catch {
+      }
+    }
+    environments.push({
+      name: envName ?? "base",
+      fileName: pattern,
+      absolutePath,
+      exists: fileExists,
+      variableCount,
+      fileSize,
+      lastModified
+    });
+  }
+  environments.sort((a, b) => {
+    const nameOrder = (name) => {
+      if (name === "base") return 0;
+      const idx = KNOWN_ENVIRONMENTS.indexOf(name);
+      return idx >= 0 ? idx + 1 : 100;
+    };
+    return nameOrder(a.name) - nameOrder(b.name);
+  });
+  return environments;
+}
+async function validateAllEnvironments(schema, cwd) {
+  const baseDir = resolve(cwd ?? process.cwd());
+  const results = /* @__PURE__ */ new Map();
+  for (const pattern of ENV_FILE_PATTERNS) {
+    const absolutePath = join(baseDir, pattern);
+    const envName = extractEnvName(pattern);
+    if (!await exists(absolutePath)) {
+      continue;
+    }
+    try {
+      const content = await readFile(absolutePath);
+      const parsed = parseEnvFile(content, absolutePath);
+      const vars = {};
+      for (const envVar of parsed.vars) {
+        vars[envVar.key] = envVar.value;
+      }
+      const errors = [];
+      const warnings = [];
+      for (const [key, schemaEntry] of Object.entries(schema)) {
+        const r = schemaEntry;
+        const rawValue = vars[key];
+        const isRequired = schemaEntry.optional !== true && schemaEntry.default === void 0 && r.hasDefault !== true;
+        if (isRequired && (rawValue === void 0 || rawValue === "")) {
+          errors.push({
+            field: key,
+            value: rawValue ?? "",
+            message: `Required variable "${key}" is missing`,
+            hint: `Set "${key}" in ${pattern}`
+          });
+        }
+        if (rawValue !== void 0 && r.type === "number") {
+          if (Number.isNaN(Number(rawValue))) {
+            errors.push({
+              field: key,
+              value: rawValue,
+              message: `"${key}" should be a number but got "${rawValue}"`,
+              hint: `Provide a valid number for "${key}"`
+            });
+          }
+        }
+        if (rawValue !== void 0 && r.type === "boolean") {
+          const lower = rawValue.toLowerCase();
+          if (!["true", "false", "1", "0", "yes", "no", "on", "off", ""].includes(lower)) {
+            errors.push({
+              field: key,
+              value: rawValue,
+              message: `"${key}" should be a boolean but got "${rawValue}"`,
+              hint: `Use true/false, 1/0, or yes/no for "${key}"`
+            });
+          }
+        }
+        if (r.isDeprecated === true && rawValue !== void 0 && rawValue !== "") {
+          const msg = r.deprecationMessage;
+          warnings.push({
+            field: key,
+            value: rawValue,
+            message: msg ?? `Variable "${key}" is deprecated`,
+            code: "DEPRECATED"
+          });
+        }
+      }
+      results.set(envName ?? pattern, {
+        valid: errors.length === 0,
+        errors,
+        warnings
+      });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      results.set(envName ?? pattern, {
+        valid: false,
+        errors: [{
+          field: "",
+          value: "",
+          message: `Failed to read/parse file: ${message}`,
+          hint: "Check that the file is a valid .env file."
+        }],
+        warnings: []
+      });
+    }
+  }
+  return results;
+}
+async function switchEnvironment(envName, cwd) {
+  const baseDir = resolve(cwd ?? process.cwd());
+  const envFile = join(baseDir, `.env.${envName}`);
+  if (!await exists(envFile)) {
+    throw new FileSystemError(
+      `Environment file ".env.${envName}" not found`,
+      {
+        path: envFile,
+        operation: "read",
+        hint: `Create a ".env.${envName}" file first, or use "ultraenv env create ${envName}".`
+      }
+    );
+  }
+  const content = await readFile(envFile);
+  const header = [
+    "# ============================================================",
+    `# Switched to environment: ${envName}`,
+    `# Source: .env.${envName}`,
+    `# Generated by ultraenv on ${(/* @__PURE__ */ new Date()).toISOString()}`,
+    "# ============================================================",
+    ""
+  ].join("\n");
+  const localPath = join(baseDir, ".env.local");
+  await writeFile(localPath, header + content);
+  const basePath = join(baseDir, ".env");
+  if (!await exists(basePath)) {
+    const baseHeader = [
+      "# ============================================================",
+      "# Base environment variables",
+      "# Generated by ultraenv",
+      "# ============================================================",
+      ""
+    ].join("\n");
+    await writeFile(basePath, baseHeader);
+  }
+}
+async function getActiveEnvironment(cwd) {
+  const baseDir = resolve(cwd ?? process.cwd());
+  const localPath = join(baseDir, ".env.local");
+  if (!await exists(localPath)) {
+    return "base";
+  }
+  try {
+    const content = await readFile(localPath);
+    const match = content.match(/^#\s*Switched to environment:\s*(\S+)/m);
+    if (match !== null && match[1] !== void 0) {
+      return match[1];
+    }
+  } catch {
+  }
+  return "base";
+}
+async function discoverEnvironments(cwd) {
+  const baseDir = resolve(cwd ?? process.cwd());
+  const discovered = [];
+  try {
+    const files = await listFiles(baseDir, false);
+    const knownNames = /* @__PURE__ */ new Set([...KNOWN_ENVIRONMENTS]);
+    for (const file of files) {
+      if (!file.startsWith(".env.")) continue;
+      if (file.endsWith(".local")) continue;
+      const name = extractEnvName(file);
+      if (name !== null && !knownNames.has(name)) {
+        discovered.push(name);
+      }
+    }
+  } catch {
+  }
+  return discovered.sort();
+}
+
+export {
+  listEnvironments,
+  validateAllEnvironments,
+  switchEnvironment,
+  getActiveEnvironment,
+  discoverEnvironments
+};

package/dist/chunk-HFXQGJY3.js

@@ -0,0 +1,445 @@
+import {
+  ParseError
+} from "./chunk-5G2DU52U.js";
+
+// src/core/parser.ts
+var NAME_START_RE = /^[A-Za-z_]/;
+var NAME_CHAR_RE = /^[A-Za-z0-9_]/;
+var COMMENT_LINE_RE = /^[ \t]*#/;
+var EXPORT_PREFIX_RE = /^[ \t]*export[ \t]+/i;
+function resolveEscapeSequence(chars, startIndex, filePath, lineNumber) {
+  const next = startIndex + 1 < chars.length ? chars[startIndex + 1] : "";
+  if (next === "") {
+    return { resolved: "\\", charsConsumed: 1 };
+  }
+  switch (next) {
+    case "n":
+      return { resolved: "\n", charsConsumed: 2 };
+    case "t":
+      return { resolved: "	", charsConsumed: 2 };
+    case "r":
+      return { resolved: "\r", charsConsumed: 2 };
+    case "\\":
+      return { resolved: "\\", charsConsumed: 2 };
+    case '"':
+      return { resolved: '"', charsConsumed: 2 };
+    /* v8 ignore start */
+    case "$":
+      return { resolved: "$", charsConsumed: 2 };
+    case "/":
+      return { resolved: "/", charsConsumed: 2 };
+    /* v8 ignore stop */
+    case "x":
+    case "X": {
+      const hex = chars.slice(startIndex + 2, startIndex + 4).join("");
+      if (hex.length === 2 && /^[0-9A-Fa-f]{2}$/.test(hex)) {
+        const codePoint = parseInt(hex, 16);
+        if (codePoint === 0) {
+          throw new ParseError("Null character (\\x00) is not allowed in .env values", {
+            line: lineNumber,
+            filePath,
+            column: startIndex
+          });
+        }
+        return { resolved: String.fromCodePoint(codePoint), charsConsumed: 4 };
+      }
+      throw new ParseError(
+        `Invalid hex escape sequence: ${"\\"}x${hex}`,
+        {
+          line: lineNumber,
+          filePath,
+          hint: "Hex escapes must be exactly 2 hex digits, e.g. \\x0A for newline."
+        }
+      );
+    }
+    case "u":
+    case "U": {
+      const hexDigits = chars.slice(startIndex + 2, startIndex + 6).join("");
+      if (hexDigits.length === 4 && /^[0-9A-Fa-f]{4}$/.test(hexDigits)) {
+        const codePoint = parseInt(hexDigits, 16);
+        if (codePoint === 0) {
+          throw new ParseError("Null character (\\u0000) is not allowed in .env values", {
+            line: lineNumber,
+            filePath
+          });
+        }
+        return { resolved: String.fromCodePoint(codePoint), charsConsumed: 6 };
+      }
+      throw new ParseError(
+        `Invalid unicode escape sequence: ${"\\"}u${hexDigits}`,
+        {
+          line: lineNumber,
+          filePath,
+          hint: 'Unicode escapes must be exactly 4 hex digits, e.g. \\u0041 for "A".'
+        }
+      );
+    }
+    /* v8 ignore start */
+    default: {
+      return { resolved: `\\${next}`, charsConsumed: 2 };
+    }
+  }
+}
+function parseDoubleQuotedValue(lines, startLineIndex, startCharIndex, filePath, lineNumber) {
+  const parts = [];
+  let currentLine = lines[startLineIndex];
+  let chars = Array.from(currentLine.slice(startCharIndex));
+  let charIndex = 0;
+  let lineIndex = startLineIndex;
+  while (lineIndex < lines.length) {
+    while (charIndex < chars.length) {
+      const ch = chars[charIndex];
+      if (ch === '"') {
+        return {
+          value: parts.join(""),
+          closed: true,
+          extraLines: lineIndex - startLineIndex
+        };
+      }
+      if (ch === "\n") {
+        parts.push("\n");
+        charIndex++;
+        continue;
+      }
+      if (ch === "\r") {
+        parts.push("\r");
+        charIndex++;
+        if (charIndex < chars.length && chars[charIndex] === "\n") {
+          charIndex++;
+        }
+        continue;
+      }
+      if (ch === "\\") {
+        const resolved = resolveEscapeSequence(
+          chars,
+          charIndex,
+          filePath,
+          lineNumber + lineIndex - startLineIndex
+        );
+        parts.push(resolved.resolved);
+        charIndex += resolved.charsConsumed;
+        continue;
+      }
+      parts.push(ch);
+      charIndex++;
+    }
+    lineIndex++;
+    if (lineIndex < lines.length) {
+      parts.push("\n");
+      currentLine = lines[lineIndex];
+      chars = Array.from(currentLine);
+      charIndex = 0;
+    }
+  }
+  return {
+    value: parts.join(""),
+    closed: false,
+    extraLines: lineIndex - startLineIndex - 1
+  };
+}
+function parseSingleQuotedValue(lines, startLineIndex, startCharIndex) {
+  const parts = [];
+  let currentLine = lines[startLineIndex];
+  let chars = Array.from(currentLine.slice(startCharIndex));
+  let charIndex = 0;
+  let lineIndex = startLineIndex;
+  while (lineIndex < lines.length) {
+    while (charIndex < chars.length) {
+      const ch = chars[charIndex];
+      if (ch === "'") {
+        return {
+          value: parts.join(""),
+          closed: true,
+          extraLines: lineIndex - startLineIndex
+        };
+      }
+      parts.push(ch);
+      charIndex++;
+    }
+    lineIndex++;
+    if (lineIndex < lines.length) {
+      parts.push("\n");
+      currentLine = lines[lineIndex];
+      chars = Array.from(currentLine);
+      charIndex = 0;
+    }
+  }
+  return {
+    value: parts.join(""),
+    closed: false,
+    extraLines: lineIndex - startLineIndex - 1
+  };
+}
+function parseBacktickQuotedValue(lines, startLineIndex, startCharIndex) {
+  const parts = [];
+  let currentLine = lines[startLineIndex];
+  let chars = Array.from(currentLine.slice(startCharIndex));
+  let charIndex = 0;
+  let lineIndex = startLineIndex;
+  while (lineIndex < lines.length) {
+    while (charIndex < chars.length) {
+      const ch = chars[charIndex];
+      if (ch === "`") {
+        return {
+          value: parts.join(""),
+          closed: true,
+          extraLines: lineIndex - startLineIndex
+        };
+      }
+      parts.push(ch);
+      charIndex++;
+    }
+    lineIndex++;
+    if (lineIndex < lines.length) {
+      parts.push("\n");
+      currentLine = lines[lineIndex];
+      chars = Array.from(currentLine);
+      charIndex = 0;
+    }
+  }
+  return {
+    value: parts.join(""),
+    closed: false,
+    extraLines: lineIndex - startLineIndex - 1
+  };
+}
+function parseKey(line, lineIndex, filePath) {
+  let i = 0;
+  const len = line.length;
+  while (i < len && (line[i] === " " || line[i] === "	")) {
+    i++;
+  }
+  const keyStart = i;
+  if (i >= len || !NAME_START_RE.test(line[i])) {
+    throw new ParseError("Expected a variable name starting with a letter or underscore", {
+      line: lineIndex + 1,
+      column: i + 1,
+      raw: line,
+      filePath
+    });
+  }
+  i++;
+  while (i < len && NAME_CHAR_RE.test(line[i])) {
+    i++;
+  }
+  const key = line.slice(keyStart, i);
+  return { key, endIndex: i };
+}
+function extractInlineComment(value) {
+  let commentStart = -1;
+  for (let i = value.length - 1; i >= 0; i--) {
+    if (value[i] === " " || value[i] === "	") {
+      const rest = value.slice(i + 1);
+      if (rest.length > 0 && rest[0] === "#") {
+        commentStart = i;
+      }
+      break;
+    }
+    if (value[i] !== " " && value[i] !== "	") {
+      break;
+    }
+  }
+  if (commentStart >= 0) {
+    return {
+      cleanValue: value.slice(0, commentStart).trimEnd(),
+      comment: value.slice(commentStart + 1).trim()
+    };
+  }
+  return { cleanValue: value, comment: "" };
+}
+function parseEnvFile(content, filePath) {
+  const resolvedPath = filePath ?? ".env";
+  const lines = splitLines(content);
+  const vars = [];
+  let lineIndex = 0;
+  while (lineIndex < lines.length) {
+    const rawLine = lines[lineIndex];
+    const oneBasedLine = lineIndex + 1;
+    if (isEmptyLine(rawLine)) {
+      lineIndex++;
+      continue;
+    }
+    if (COMMENT_LINE_RE.test(rawLine)) {
+      lineIndex++;
+      continue;
+    }
+    let workingLine = rawLine;
+    const exportMatch = EXPORT_PREFIX_RE.exec(workingLine);
+    if (exportMatch !== null) {
+      workingLine = workingLine.slice(exportMatch[0].length);
+    }
+    if (isEmptyLine(workingLine) || COMMENT_LINE_RE.test(workingLine)) {
+      lineIndex++;
+      continue;
+    }
+    let key;
+    let afterKeyIndex;
+    try {
+      const parsed = parseKey(workingLine, lineIndex, resolvedPath);
+      key = parsed.key;
+      afterKeyIndex = parsed.endIndex;
+    } catch {
+      lineIndex++;
+      continue;
+    }
+    while (afterKeyIndex < workingLine.length && (workingLine[afterKeyIndex] === " " || workingLine[afterKeyIndex] === "	")) {
+      afterKeyIndex++;
+    }
+    if (afterKeyIndex >= workingLine.length || workingLine[afterKeyIndex] !== "=") {
+      const restAfterKey = workingLine.slice(afterKeyIndex).trim();
+      if (restAfterKey === "") {
+        const varEntry2 = {
+          key,
+          value: "",
+          raw: "",
+          source: resolvedPath,
+          lineNumber: oneBasedLine,
+          comment: ""
+        };
+        vars.push(varEntry2);
+        lineIndex++;
+        continue;
+      }
+      lineIndex++;
+      continue;
+    }
+    afterKeyIndex++;
+    while (afterKeyIndex < workingLine.length && (workingLine[afterKeyIndex] === " " || workingLine[afterKeyIndex] === "	")) {
+      afterKeyIndex++;
+    }
+    const valueStartIndex = afterKeyIndex;
+    if (valueStartIndex >= workingLine.length) {
+      const varEntry2 = {
+        key,
+        value: "",
+        raw: "",
+        source: resolvedPath,
+        lineNumber: oneBasedLine,
+        comment: ""
+      };
+      vars.push(varEntry2);
+      lineIndex++;
+      continue;
+    }
+    const firstChar = workingLine[valueStartIndex];
+    let value;
+    let raw;
+    let comment = "";
+    let extraLinesConsumed = 0;
+    if (firstChar === '"') {
+      const result = parseDoubleQuotedValue(
+        lines,
+        lineIndex,
+        valueStartIndex + 1,
+        resolvedPath,
+        oneBasedLine
+      );
+      if (!result.closed) {
+        throw new ParseError("Unterminated double-quoted string", {
+          line: oneBasedLine,
+          raw: workingLine,
+          filePath: resolvedPath,
+          hint: 'Make sure every double-quoted value has a closing ".'
+        });
+      }
+      value = result.value;
+      raw = `"${result.value}"`;
+      extraLinesConsumed = result.extraLines;
+      const closingQuoteLine = lines[lineIndex + extraLinesConsumed];
+      const afterClosingQuote = closingQuoteLine.slice(
+        valueStartIndex + 1 + result.value.length + 1
+      );
+      const trimmedAfter = afterClosingQuote.trim();
+      if (trimmedAfter.startsWith("#")) {
+        comment = trimmedAfter.slice(1).trim();
+      }
+    } else if (firstChar === "'") {
+      const result = parseSingleQuotedValue(
+        lines,
+        lineIndex,
+        valueStartIndex + 1
+      );
+      if (!result.closed) {
+        throw new ParseError("Unterminated single-quoted string", {
+          line: oneBasedLine,
+          raw: workingLine,
+          filePath: resolvedPath,
+          hint: "Make sure every single-quoted value has a closing '."
+        });
+      }
+      value = result.value;
+      raw = `'${result.value}'`;
+      extraLinesConsumed = result.extraLines;
+      const closingQuoteLine = lines[lineIndex + extraLinesConsumed];
+      const afterClosingQuote = closingQuoteLine.slice(
+        valueStartIndex + 1 + result.value.length + 1
+      );
+      const trimmedAfter = afterClosingQuote.trim();
+      if (trimmedAfter.startsWith("#")) {
+        comment = trimmedAfter.slice(1).trim();
+      }
+    } else if (firstChar === "`") {
+      const result = parseBacktickQuotedValue(
+        lines,
+        lineIndex,
+        valueStartIndex + 1
+      );
+      if (!result.closed) {
+        throw new ParseError("Unterminated backtick-quoted string", {
+          line: oneBasedLine,
+          raw: workingLine,
+          filePath: resolvedPath,
+          hint: "Make sure every backtick-quoted value has a closing `."
+        });
+      }
+      value = result.value;
+      raw = `\`${result.value}\``;
+      extraLinesConsumed = result.extraLines;
+      const closingQuoteLine = lines[lineIndex + extraLinesConsumed];
+      const afterClosingQuote = closingQuoteLine.slice(
+        valueStartIndex + 1 + result.value.length + 1
+      );
+      const trimmedAfter = afterClosingQuote.trim();
+      if (trimmedAfter.startsWith("#")) {
+        comment = trimmedAfter.slice(1).trim();
+      }
+    } else {
+      let rawValue = workingLine.slice(valueStartIndex);
+      const extracted = extractInlineComment(rawValue);
+      value = extracted.cleanValue;
+      comment = extracted.comment;
+      raw = rawValue;
+    }
+    const varEntry = {
+      key,
+      value,
+      raw,
+      source: resolvedPath,
+      lineNumber: oneBasedLine,
+      comment
+    };
+    vars.push(varEntry);
+    lineIndex += 1 + extraLinesConsumed;
+  }
+  return {
+    path: resolvedPath,
+    vars,
+    exists: true
+  };
+}
+function splitLines(content) {
+  const normalized = content.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+  return normalized.split("\n");
+}
+function isEmptyLine(line) {
+  for (let i = 0; i < line.length; i++) {
+    if (line[i] !== " " && line[i] !== "	") {
+      return false;
+    }
+  }
+  return true;
+}
+
+export {
+  parseEnvFile
+};