@zqw-cli/qenv 1.0.0

package/dist/index.js

@@ -0,0 +1,1487 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/index.ts
+var import_commander = require("commander");
+var import_chalk5 = __toESM(require("chalk"));
+
+// src/utils/platform.ts
+var import_node_child_process = require("child_process");
+function getPlatform() {
+  switch (process.platform) {
+    case "win32":
+      return "windows";
+    case "darwin":
+      return "macos";
+    default:
+      return "linux";
+  }
+}
+function isElevated() {
+  var _a;
+  const platform = getPlatform();
+  if (platform === "windows") {
+    try {
+      (0, import_node_child_process.execSync)("net session", { stdio: "ignore" });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  return ((_a = process.getuid) == null ? void 0 : _a.call(process)) === 0;
+}
+function getHomeDir() {
+  return process.env.HOME || process.env.USERPROFILE || "";
+}
+
+// src/drivers/windows.ts
+var import_node_child_process2 = require("child_process");
+
+// src/utils/logger.ts
+var import_chalk = __toESM(require("chalk"));
+var prefix = import_chalk.default.blue("qenv");
+var logger = {
+  success(msg) {
+    console.log(`${prefix} ${import_chalk.default.green("\u2714")} ${msg}`);
+  },
+  warn(msg) {
+    console.log(`${prefix} ${import_chalk.default.yellow("\u26A0")} ${msg}`);
+  },
+  error(msg) {
+    console.error(`${prefix} ${import_chalk.default.red("\u2716")} ${msg}`);
+  },
+  info(msg) {
+    console.log(`${prefix} ${import_chalk.default.cyan("\u2139")} ${msg}`);
+  },
+  plain(msg) {
+    console.log(msg);
+  },
+  debug(msg) {
+    if (process.env.QENV_VERBOSE === "1") {
+      console.log(`${prefix} ${import_chalk.default.gray("[debug]")} ${msg}`);
+    }
+  },
+  table(headers, rows) {
+    const colWidths = headers.map(
+      (h, i) => Math.max(h.length, ...rows.map((r) => (r[i] || "").length))
+    );
+    const headerLine = headers.map((h, i) => h.padEnd(colWidths[i])).join("  ");
+    console.log(`  ${import_chalk.default.bold(headerLine)}`);
+    const sep = colWidths.map((w) => "\u2500".repeat(w)).join("\u2500\u2500");
+    console.log(`  ${sep}`);
+    for (const row of rows) {
+      const line = row.map((cell, i) => cell.padEnd(colWidths[i])).join("  ");
+      console.log(`  ${line}`);
+    }
+  }
+};
+
+// src/utils/validator.ts
+var VAR_NAME_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/;
+var WINDOWS_SETX_MAX_LENGTH = 1024;
+function validateName(name) {
+  if (!name || name.trim().length === 0) {
+    return { valid: false, message: "Variable name cannot be empty" };
+  }
+  if (!VAR_NAME_PATTERN.test(name)) {
+    return {
+      valid: false,
+      message: `Invalid variable name "${name}". Must match /^[A-Za-z_][A-Za-z0-9_]*$/`
+    };
+  }
+  return { valid: true };
+}
+function validateValueForWindows(value) {
+  if (value.length > WINDOWS_SETX_MAX_LENGTH) {
+    return {
+      valid: false,
+      message: `Value exceeds Windows setx limit of ${WINDOWS_SETX_MAX_LENGTH} characters (got ${value.length})`
+    };
+  }
+  return { valid: true };
+}
+function parseDotEnvLine(line) {
+  const trimmed = line.trim();
+  if (!trimmed || trimmed.startsWith("#")) {
+    return null;
+  }
+  const eqIndex = trimmed.indexOf("=");
+  if (eqIndex === -1) {
+    return null;
+  }
+  const key = trimmed.slice(0, eqIndex).trim();
+  let value = trimmed.slice(eqIndex + 1).trim();
+  if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+    value = value.slice(1, -1);
+  }
+  return { key, value };
+}
+function serializeDotEnv(vars) {
+  return Object.entries(vars).map(([key, value]) => {
+    const needsQuotes = /[\s#"'=]/.test(value);
+    const quoted = needsQuotes ? `"${value.replace(/"/g, '\\"')}"` : value;
+    return `${key}=${quoted}`;
+  }).join("\n");
+}
+
+// src/drivers/windows.ts
+var WindowsDriver = class {
+  constructor(options = {}) {
+    this.systemWide = options.systemWide || false;
+  }
+  async get(name) {
+    try {
+      const regPath = this.systemWide ? "HKLM\\System\\CurrentControlSet\\Control\\Session Manager\\Environment" : "HKCU\\Environment";
+      const output = (0, import_node_child_process2.execSync)(`reg query "${regPath}" /v ${name}`, {
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      const match = output.match(/\s+\S+\s+REG_(?:SZ|EXPAND_SZ)\s+(.*)/);
+      if (match) {
+        return match[1].trim();
+      }
+      return void 0;
+    } catch {
+      return void 0;
+    }
+  }
+  async set(name, value) {
+    if (this.systemWide) {
+      if (!isElevated()) {
+        throw new Error("System-wide operations require administrator privileges. Run as Administrator.");
+      }
+      (0, import_node_child_process2.execSync)(
+        `reg add "HKLM\\System\\CurrentControlSet\\Control\\Session Manager\\Environment" /v ${name} /t REG_EXPAND_SZ /d "${value}" /f`,
+        { stdio: "pipe" }
+      );
+    } else {
+      const validation = validateValueForWindows(value);
+      if (!validation.valid) {
+        throw new Error(validation.message);
+      }
+      (0, import_node_child_process2.execSync)(`setx ${name} "${value}"`, { stdio: "pipe" });
+    }
+    this.broadcastSettingChange();
+  }
+  async remove(name) {
+    const regPath = this.systemWide ? "HKLM\\System\\CurrentControlSet\\Control\\Session Manager\\Environment" : "HKCU\\Environment";
+    if (this.systemWide && !isElevated()) {
+      throw new Error("System-wide operations require administrator privileges. Run as Administrator.");
+    }
+    try {
+      (0, import_node_child_process2.execSync)(`reg delete "${regPath}" /v ${name} /f`, { stdio: "pipe" });
+      this.broadcastSettingChange();
+    } catch {
+      throw new Error(`Failed to remove variable "${name}". It may not exist.`);
+    }
+  }
+  async list() {
+    const result = {};
+    try {
+      const regPath = this.systemWide ? "HKLM\\System\\CurrentControlSet\\Control\\Session Manager\\Environment" : "HKCU\\Environment";
+      const output = (0, import_node_child_process2.execSync)(`reg query "${regPath}"`, {
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      const lines = output.split("\n");
+      for (const line of lines) {
+        const match = line.match(/^\s+(\S+)\s+REG_(?:SZ|EXPAND_SZ)\s+(.*)/);
+        if (match) {
+          result[match[1].trim()] = match[2].trim();
+        }
+      }
+    } catch {
+      logger.debug("Failed to query Windows registry");
+    }
+    return result;
+  }
+  /**
+   * Broadcast WM_SETTINGCHANGE to notify other processes of env change.
+   */
+  broadcastSettingChange() {
+    try {
+      (0, import_node_child_process2.execSync)(
+        `powershell -Command "[System.Environment]::SetEnvironmentVariable('__qenv_broadcast__', $null, 'User')"`,
+        { stdio: "pipe" }
+      );
+    } catch {
+      logger.debug("Failed to broadcast WM_SETTINGCHANGE");
+    }
+  }
+};
+
+// src/drivers/unix.ts
+var import_node_fs = require("fs");
+var import_node_child_process3 = require("child_process");
+
+// src/shell/detect.ts
+function detectShell() {
+  const override = process.env.QENV_SHELL;
+  if (override && isValidShell(override)) {
+    return override;
+  }
+  if (process.platform === "win32") {
+    if (process.env.PSModulePath) {
+      return "pwsh";
+    }
+    return "cmd";
+  }
+  const shell = process.env.SHELL || "";
+  if (shell.includes("zsh")) return "zsh";
+  if (shell.includes("fish")) return "fish";
+  if (shell.includes("bash")) return "bash";
+  const parentPid = process.ppid;
+  if (parentPid) {
+    try {
+      const { execSync: execSync4 } = require("child_process");
+      const parentName = execSync4(`ps -p ${parentPid} -o comm=`, {
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "pipe"]
+      }).trim();
+      if (parentName.includes("zsh")) return "zsh";
+      if (parentName.includes("fish")) return "fish";
+      if (parentName.includes("bash")) return "bash";
+      if (parentName.includes("pwsh") || parentName.includes("powershell")) return "pwsh";
+    } catch {
+    }
+  }
+  return "bash";
+}
+function isValidShell(shell) {
+  return ["bash", "zsh", "fish", "pwsh", "cmd"].includes(shell);
+}
+function getShellName(shell) {
+  const names = {
+    bash: "Bash",
+    zsh: "Zsh",
+    fish: "Fish",
+    pwsh: "PowerShell",
+    cmd: "Command Prompt"
+  };
+  return names[shell] || shell;
+}
+
+// src/drivers/unix.ts
+var SHELL_FILES = {
+  zsh: ["~/.zshrc", "~/.zprofile"],
+  bash: ["~/.bashrc", "~/.bash_profile", "~/.profile"],
+  fish: ["~/.config/fish/config.fish"]
+};
+var QENV_MARKER = "# qenv:managed";
+var UnixDriver = class {
+  constructor(options = {}) {
+    this.systemWide = options.systemWide || false;
+  }
+  async get(name) {
+    if (process.env[name] !== void 0) {
+      return process.env[name];
+    }
+    const configPath = this.getConfigFilePath();
+    if (configPath && (0, import_node_fs.existsSync)(configPath)) {
+      const content = (0, import_node_fs.readFileSync)(configPath, "utf-8");
+      const regex = new RegExp(`^export ${name}="(.+)"\\s*${QENV_MARKER.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}$`, "m");
+      const match = content.match(regex);
+      if (match) {
+        return match[1];
+      }
+    }
+    return void 0;
+  }
+  async set(name, value) {
+    if (this.systemWide) {
+      const line = `${name}="${value}"`;
+      try {
+        (0, import_node_child_process3.execSync)(`sudo sh -c 'echo "${line} ${QENV_MARKER}" >> /etc/environment'`, { stdio: "pipe" });
+      } catch {
+        throw new Error("System-wide operations require sudo privileges.");
+      }
+      return;
+    }
+    const configPath = this.getConfigFilePath();
+    if (!configPath) {
+      throw new Error("Could not determine shell configuration file.");
+    }
+    const exportLine = `export ${name}="${value}" ${QENV_MARKER}`;
+    let content = "";
+    if ((0, import_node_fs.existsSync)(configPath)) {
+      content = (0, import_node_fs.readFileSync)(configPath, "utf-8");
+    }
+    const regex = new RegExp(`^export ${name}=.*${QENV_MARKER.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}$`, "m");
+    if (regex.test(content)) {
+      content = content.replace(regex, exportLine);
+    } else {
+      content = content.trimEnd() + "\n" + exportLine + "\n";
+    }
+    (0, import_node_fs.writeFileSync)(configPath, content, "utf-8");
+    logger.debug(`Wrote to ${configPath}`);
+  }
+  async remove(name) {
+    if (this.systemWide) {
+      try {
+        (0, import_node_child_process3.execSync)(
+          `sudo sed -i '/^${name}=.*${QENV_MARKER.replace(/\//g, "\\/")}/d' /etc/environment`,
+          { stdio: "pipe" }
+        );
+      } catch {
+        throw new Error("System-wide operations require sudo privileges.");
+      }
+      return;
+    }
+    const configPath = this.getConfigFilePath();
+    if (!configPath || !(0, import_node_fs.existsSync)(configPath)) {
+      throw new Error(`Variable "${name}" not found in shell configuration.`);
+    }
+    let content = (0, import_node_fs.readFileSync)(configPath, "utf-8");
+    const regex = new RegExp(`^export ${name}=.*${QENV_MARKER.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\n?`, "m");
+    if (!regex.test(content)) {
+      throw new Error(`Variable "${name}" is not managed by qenv.`);
+    }
+    content = content.replace(regex, "");
+    (0, import_node_fs.writeFileSync)(configPath, content, "utf-8");
+  }
+  async list() {
+    const result = {};
+    for (const [key, value] of Object.entries(process.env)) {
+      if (value !== void 0) {
+        result[key] = value;
+      }
+    }
+    return result;
+  }
+  /**
+   * Determine which shell config file to use.
+   */
+  getConfigFilePath() {
+    const home = getHomeDir();
+    if (!home) return null;
+    const shell = detectShell();
+    const files = SHELL_FILES[shell] || SHELL_FILES["bash"];
+    for (const file of files) {
+      const resolved = file.replace("~", home);
+      if ((0, import_node_fs.existsSync)(resolved)) {
+        return resolved;
+      }
+    }
+    if (files.length > 0) {
+      return files[0].replace("~", home);
+    }
+    return null;
+  }
+};
+
+// src/drivers/dotenv.ts
+var import_node_fs2 = require("fs");
+var import_node_path = require("path");
+var DotenvDriver = class {
+  constructor(filePath = ".env") {
+    this.filePath = (0, import_node_path.resolve)(process.cwd(), filePath);
+  }
+  async get(name) {
+    const vars = await this.readFile();
+    return vars[name];
+  }
+  async set(name, value) {
+    const vars = await this.readFile();
+    vars[name] = value;
+    await this.writeFile(vars);
+  }
+  async remove(name) {
+    const vars = await this.readFile();
+    if (!(name in vars)) {
+      throw new Error(`Variable "${name}" not found in ${this.filePath}`);
+    }
+    delete vars[name];
+    await this.writeFile(vars);
+  }
+  async list() {
+    return this.readFile();
+  }
+  /**
+   * Remove all variables from the .env file.
+   */
+  async clear() {
+    await this.writeFile({});
+  }
+  /**
+   * Read and parse the .env file.
+   */
+  async readFile() {
+    const result = {};
+    if (!(0, import_node_fs2.existsSync)(this.filePath)) {
+      return result;
+    }
+    const content = (0, import_node_fs2.readFileSync)(this.filePath, "utf-8");
+    const lines = content.split("\n");
+    for (const line of lines) {
+      const parsed = parseDotEnvLine(line);
+      if (parsed) {
+        result[parsed.key] = parsed.value;
+      }
+    }
+    return result;
+  }
+  /**
+   * Write variables to the .env file, preserving comments.
+   */
+  async writeFile(vars) {
+    const lines = [];
+    if ((0, import_node_fs2.existsSync)(this.filePath)) {
+      const content = (0, import_node_fs2.readFileSync)(this.filePath, "utf-8");
+      const existingLines = content.split("\n");
+      const writtenKeys = /* @__PURE__ */ new Set();
+      for (const line of existingLines) {
+        const parsed = parseDotEnvLine(line);
+        if (parsed) {
+          if (parsed.key in vars) {
+            const value = vars[parsed.key];
+            const needsQuotes = /[\s#"'=]/.test(value);
+            const quoted = needsQuotes ? `"${value.replace(/"/g, '\\"')}"` : value;
+            lines.push(`${parsed.key}=${quoted}`);
+            writtenKeys.add(parsed.key);
+          }
+        } else {
+          lines.push(line);
+        }
+      }
+      for (const [key, value] of Object.entries(vars)) {
+        if (!writtenKeys.has(key)) {
+          const needsQuotes = /[\s#"'=]/.test(value);
+          const quoted = needsQuotes ? `"${value.replace(/"/g, '\\"')}"` : value;
+          lines.push(`${key}=${quoted}`);
+        }
+      }
+    } else {
+      for (const [key, value] of Object.entries(vars)) {
+        const needsQuotes = /[\s#"'=]/.test(value);
+        const quoted = needsQuotes ? `"${value.replace(/"/g, '\\"')}"` : value;
+        lines.push(`${key}=${quoted}`);
+      }
+    }
+    (0, import_node_fs2.writeFileSync)(this.filePath, lines.join("\n"), "utf-8");
+  }
+  /** Get the file path of this driver */
+  getFilePath() {
+    return this.filePath;
+  }
+};
+
+// src/drivers/index.ts
+function getSystemDriver(options = {}) {
+  const platform = getPlatform();
+  if (platform === "windows") {
+    return new WindowsDriver(options);
+  }
+  return new UnixDriver(options);
+}
+function getDotenvDriver(filePath) {
+  return new DotenvDriver(filePath);
+}
+
+// src/manifest/index.ts
+var import_conf = __toESM(require("conf"));
+var SCHEMA = {
+  version: {
+    type: "number",
+    default: 1
+  },
+  vars: {
+    type: "object",
+    default: {}
+  }
+};
+function getVersion() {
+  try {
+    return `qenv@1.0.0`;
+  } catch {
+    return "qenv@unknown";
+  }
+}
+var ManifestManager = class {
+  constructor() {
+    this.store = new import_conf.default({
+      projectName: "qenv",
+      schema: SCHEMA,
+      defaults: {
+        version: 1,
+        vars: {}
+      }
+    });
+  }
+  /**
+   * Get all tracked variables.
+   */
+  getAll() {
+    return this.store.get("vars") || {};
+  }
+  /**
+   * Get a single variable entry.
+   */
+  get(name) {
+    const vars = this.getAll();
+    return vars[name];
+  }
+  /**
+   * Track a variable in the manifest.
+   */
+  set(name, scope, filePath = null) {
+    const vars = this.getAll();
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const existing = vars[name];
+    vars[name] = {
+      scope,
+      filePath,
+      setAt: (existing == null ? void 0 : existing.setAt) || now,
+      updatedAt: now,
+      setBy: getVersion()
+    };
+    this.store.set("vars", vars);
+  }
+  /**
+   * Remove a variable from the manifest.
+   */
+  remove(name) {
+    const vars = this.getAll();
+    if (!(name in vars)) {
+      return false;
+    }
+    delete vars[name];
+    this.store.set("vars", vars);
+    return true;
+  }
+  /**
+   * Check if a variable is tracked.
+   */
+  has(name) {
+    const vars = this.getAll();
+    return name in vars;
+  }
+  /**
+   * Clear all manifest entries.
+   */
+  clear() {
+    this.store.set("vars", {});
+  }
+  /**
+   * Remove specific entries by name.
+   */
+  removeMany(names) {
+    const vars = this.getAll();
+    let removed = 0;
+    for (const name of names) {
+      if (name in vars) {
+        delete vars[name];
+        removed++;
+      }
+    }
+    this.store.set("vars", vars);
+    return removed;
+  }
+  /**
+   * Get the config file path (useful for debugging).
+   */
+  get path() {
+    return this.store.path;
+  }
+};
+var manifest = new ManifestManager();
+
+// src/shell/eval.ts
+function outputShellEval(key, value, action, shell) {
+  const expressions = {
+    bash: {
+      set: `export ${key}="${escapeValue(value || "")}"`,
+      unset: `unset ${key}`
+    },
+    zsh: {
+      set: `export ${key}="${escapeValue(value || "")}"`,
+      unset: `unset ${key}`
+    },
+    fish: {
+      set: `set -gx ${key} "${escapeValue(value || "")}"`,
+      unset: `set -e ${key}`
+    },
+    pwsh: {
+      set: `$env:${key} = "${escapeValue(value || "")}"`,
+      unset: `Remove-Item Env:${key} -ErrorAction SilentlyContinue`
+    },
+    cmd: {
+      set: `set "${key}=${value || ""}"`,
+      unset: `set "${key}="`
+    }
+  };
+  const shellExprs = expressions[shell] || expressions["bash"];
+  const expr = shellExprs[action];
+  if (expr) {
+    process.stdout.write(expr);
+  }
+}
+function escapeValue(value) {
+  return value.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\$/g, "\\$").replace(/`/g, "\\`");
+}
+function outputNoOp() {
+  process.stdout.write(":");
+}
+
+// src/commands/set.ts
+function registerSetCommand(program, isShellEval) {
+  program.command("set <name> <value>").description("Set an environment variable").option("--local", "Set for current shell session only (requires qenv init)").option("--system", "Set system-wide (requires admin/sudo)").option("--file [path]", "Write to .env file (default: ./.env)").option("--json", "Parse value as JSON").option("--overwrite", "Overwrite if already exists").addHelpText("after", `
+Examples:
+  $ qenv set NODE_ENV production
+  $ qenv set API_KEY sk-xxx --local
+  $ qenv set PORT 3000 --file .env.local
+`).action(async (name, value, options) => {
+    const validation = validateName(name);
+    if (!validation.valid) {
+      logger.error(validation.message);
+      process.exitCode = 1;
+      return;
+    }
+    let finalValue = value;
+    if (options.json) {
+      try {
+        JSON.parse(value);
+        finalValue = value;
+      } catch {
+        logger.error(`Invalid JSON value: ${value}`);
+        process.exitCode = 1;
+        return;
+      }
+    }
+    try {
+      if (options.local) {
+        if (isShellEval) {
+          const shell = detectShell();
+          outputShellEval(name, finalValue, "set", shell);
+        } else {
+          logger.warn("--local requires qenv init. Run `qenv init` first.");
+          logger.info('Hint: use `eval "$(qenv --shell-eval set ' + name + " " + value + ' --local)"` as a workaround.');
+        }
+        return;
+      }
+      if (options.file !== void 0) {
+        const filePath = typeof options.file === "string" ? options.file : ".env";
+        const driver2 = getDotenvDriver(filePath);
+        if (!options.overwrite) {
+          const existing = await driver2.get(name);
+          if (existing !== void 0) {
+            logger.warn(`Variable "${name}" already exists in ${filePath}. Use --overwrite to replace.`);
+            process.exitCode = 1;
+            return;
+          }
+        }
+        await driver2.set(name, finalValue);
+        manifest.set(name, "file", driver2.getFilePath());
+        if (isShellEval) {
+          outputNoOp();
+        } else {
+          logger.success(`Set ${name} in ${filePath}`);
+        }
+        return;
+      }
+      const driver = getSystemDriver({ systemWide: options.system });
+      if (!options.overwrite) {
+        const existing = await driver.get(name);
+        if (existing !== void 0) {
+          logger.warn(`Variable "${name}" already exists. Use --overwrite to replace.`);
+          process.exitCode = 1;
+          return;
+        }
+      }
+      await driver.set(name, finalValue);
+      manifest.set(name, options.system ? "system-wide" : "system");
+      if (isShellEval) {
+        outputNoOp();
+      } else {
+        const scope = options.system ? "system-wide" : "user";
+        logger.success(`Set ${name}=${finalValue} (${scope})`);
+      }
+    } catch (err) {
+      logger.error(err.message || String(err));
+      process.exitCode = 1;
+    }
+  });
+}
+
+// src/commands/get.ts
+function registerGetCommand(program) {
+  program.command("get <name>").description("Get an environment variable value").option("--source", "Show the source of the variable (qenv/system/file)").option("--file [path]", "Read from .env file (default: ./.env)").option("--json", "Output as JSON").option("--raw", "Output raw value only (for scripting)").addHelpText("after", `
+Examples:
+  $ qenv get NODE_ENV
+  $ qenv get API_KEY --source
+  $ qenv get DATABASE_URL --file .env.prod
+  $ qenv get PORT --raw
+`).action(async (name, options) => {
+    const validation = validateName(name);
+    if (!validation.valid) {
+      logger.error(validation.message);
+      process.exitCode = 1;
+      return;
+    }
+    try {
+      let value;
+      let source = "system";
+      if (options.file !== void 0) {
+        const filePath = typeof options.file === "string" ? options.file : ".env";
+        const driver = getDotenvDriver(filePath);
+        value = await driver.get(name);
+        source = `file (${filePath})`;
+      } else {
+        const driver = getSystemDriver();
+        value = await driver.get(name);
+        const entry = manifest.get(name);
+        if (entry) {
+          source = `qenv (${entry.scope})`;
+        }
+      }
+      if (value === void 0) {
+        if (options.raw) {
+          process.exitCode = 1;
+          return;
+        }
+        logger.warn(`Variable "${name}" not found`);
+        process.exitCode = 1;
+        return;
+      }
+      if (options.raw) {
+        process.stdout.write(value);
+        return;
+      }
+      if (options.json) {
+        logger.plain(JSON.stringify({ name, value, source }));
+        return;
+      }
+      if (options.source) {
+        logger.plain(`${name}=${value}`);
+        logger.info(`Source: ${source}`);
+      } else {
+        logger.plain(`${name}=${value}`);
+      }
+    } catch (err) {
+      logger.error(err.message || String(err));
+      process.exitCode = 1;
+    }
+  });
+}
+
+// src/commands/remove.ts
+var import_node_readline = require("readline");
+function confirm(message) {
+  const rl = (0, import_node_readline.createInterface)({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve4) => {
+    rl.question(`${message} (y/N) `, (answer) => {
+      rl.close();
+      resolve4(answer.toLowerCase() === "y" || answer.toLowerCase() === "yes");
+    });
+  });
+}
+function registerRemoveCommand(program, isShellEval) {
+  program.command("remove <name>").alias("rm").description("Remove an environment variable").option("--system", "Remove system-wide variable (requires admin/sudo)").option("--local", "Remove from current shell session").option("--file [path]", "Remove from .env file (default: ./.env)").option("--force", "Skip confirmation prompt").option("--all", "Remove all variables (only with --file)").addHelpText("after", `
+Examples:
+  $ qenv remove NODE_ENV
+  $ qenv remove API_KEY --force
+  $ qenv remove DATABASE_URL --file .env.prod
+  $ qenv remove --all --file
+`).action(async (name, options) => {
+    try {
+      if (options.local) {
+        if (isShellEval) {
+          const shell = detectShell();
+          outputShellEval(name, null, "unset", shell);
+        } else {
+          logger.warn("--local requires qenv init. Run `qenv init` first.");
+        }
+        return;
+      }
+      if (options.file !== void 0) {
+        const filePath = typeof options.file === "string" ? options.file : ".env";
+        const driver2 = getDotenvDriver(filePath);
+        if (options.all) {
+          if (!options.force) {
+            const confirmed = await confirm(`Remove all variables from ${filePath}?`);
+            if (!confirmed) {
+              logger.info("Cancelled.");
+              return;
+            }
+          }
+          await driver2.clear();
+          logger.success(`Cleared all variables from ${filePath}`);
+          if (isShellEval) outputNoOp();
+          return;
+        }
+        const validation2 = validateName(name);
+        if (!validation2.valid) {
+          logger.error(validation2.message);
+          process.exitCode = 1;
+          return;
+        }
+        await driver2.remove(name);
+        manifest.remove(name);
+        if (isShellEval) {
+          outputNoOp();
+        } else {
+          logger.success(`Removed ${name} from ${filePath}`);
+        }
+        return;
+      }
+      const validation = validateName(name);
+      if (!validation.valid) {
+        logger.error(validation.message);
+        process.exitCode = 1;
+        return;
+      }
+      if (!options.force) {
+        const confirmed = await confirm(`Remove variable "${name}"?`);
+        if (!confirmed) {
+          logger.info("Cancelled.");
+          return;
+        }
+      }
+      const driver = getSystemDriver({ systemWide: options.system });
+      await driver.remove(name);
+      manifest.remove(name);
+      if (isShellEval) {
+        outputNoOp();
+      } else {
+        logger.success(`Removed ${name}`);
+      }
+    } catch (err) {
+      logger.error(err.message || String(err));
+      process.exitCode = 1;
+    }
+  });
+}
+
+// src/commands/list.ts
+var import_chalk2 = __toESM(require("chalk"));
+function timeAgo(dateStr) {
+  const date = new Date(dateStr);
+  const now = /* @__PURE__ */ new Date();
+  const diffMs = now.getTime() - date.getTime();
+  const diffSec = Math.floor(diffMs / 1e3);
+  const diffMin = Math.floor(diffSec / 60);
+  const diffHour = Math.floor(diffMin / 60);
+  const diffDay = Math.floor(diffHour / 24);
+  if (diffDay > 0) return `${diffDay} day${diffDay > 1 ? "s" : ""} ago`;
+  if (diffHour > 0) return `${diffHour} hour${diffHour > 1 ? "s" : ""} ago`;
+  if (diffMin > 0) return `${diffMin} min${diffMin > 1 ? "s" : ""} ago`;
+  return "just now";
+}
+function maskValue(value) {
+  if (value.length <= 6) return value;
+  const visible = value.slice(0, 3);
+  const tail = value.slice(-3);
+  return `${visible}***${tail}`;
+}
+function registerListCommand(program) {
+  program.command("list").alias("ls").description("List environment variables").option("--all", "List all system environment variables").option("--file [path]", "List variables from .env file (default: ./.env)").option("--json", "Output as JSON").option("--verify", "Verify manifest entries against actual system values").option("--stale", "Show only stale (not found) manifest entries").addHelpText("after", `
+Examples:
+  $ qenv list
+  $ qenv list --all
+  $ qenv list --file .env.prod
+  $ qenv list --json
+  $ qenv list --verify
+  $ qenv list --stale
+`).action(async (options) => {
+    try {
+      if (options.file !== void 0) {
+        const filePath = typeof options.file === "string" ? options.file : ".env";
+        const driver2 = getDotenvDriver(filePath);
+        const vars2 = await driver2.list();
+        if (options.json) {
+          logger.plain(JSON.stringify(vars2, null, 2));
+          return;
+        }
+        const entries2 = Object.entries(vars2);
+        if (entries2.length === 0) {
+          logger.info(`No variables found in ${filePath}`);
+          return;
+        }
+        logger.plain("");
+        logger.table(
+          ["NAME", "VALUE"],
+          entries2.map(([key, value]) => [key, value])
+        );
+        logger.plain("");
+        return;
+      }
+      if (options.all) {
+        const driver2 = getSystemDriver();
+        const vars2 = await driver2.list();
+        if (options.json) {
+          logger.plain(JSON.stringify(vars2, null, 2));
+          return;
+        }
+        const entries2 = Object.entries(vars2).sort(([a], [b]) => a.localeCompare(b));
+        if (entries2.length === 0) {
+          logger.info("No environment variables found");
+          return;
+        }
+        logger.plain("");
+        for (const [key, value] of entries2) {
+          logger.plain(`  ${import_chalk2.default.bold(key)}=${value}`);
+        }
+        logger.plain(`
+  Total: ${entries2.length} variables
+`);
+        return;
+      }
+      const vars = manifest.getAll();
+      const entries = Object.entries(vars);
+      if (entries.length === 0) {
+        logger.info("No variables managed by qenv. Use `qenv set` to add variables.");
+        return;
+      }
+      const driver = getSystemDriver();
+      const rows = [];
+      let staleCount = 0;
+      for (const [name, entry] of entries) {
+        let currentValue;
+        if (entry.scope === "file" && entry.filePath) {
+          const fileDriver = getDotenvDriver(entry.filePath);
+          currentValue = await fileDriver.get(name);
+        } else {
+          currentValue = await driver.get(name);
+        }
+        const isStale = currentValue === void 0;
+        if (isStale) staleCount++;
+        if (options.stale && !isStale) continue;
+        const valueDisplay = isStale ? import_chalk2.default.yellow("(not found) \u26A0") : maskValue(currentValue);
+        const updated = timeAgo(entry.updatedAt);
+        rows.push([name, valueDisplay, entry.scope, updated]);
+      }
+      if (options.json) {
+        const jsonData = {};
+        for (const [name, entry] of entries) {
+          let currentValue;
+          if (entry.scope === "file" && entry.filePath) {
+            const fileDriver = getDotenvDriver(entry.filePath);
+            currentValue = await fileDriver.get(name);
+          } else {
+            currentValue = await driver.get(name);
+          }
+          jsonData[name] = {
+            ...entry,
+            currentValue: currentValue || null,
+            stale: currentValue === void 0
+          };
+        }
+        logger.plain(JSON.stringify(jsonData, null, 2));
+        return;
+      }
+      if (rows.length === 0) {
+        logger.info("No stale entries found.");
+        return;
+      }
+      logger.plain("");
+      logger.table(["NAME", "VALUE", "SCOPE", "UPDATED"], rows);
+      logger.plain("");
+      if (staleCount > 0) {
+        logger.warn(
+          `${staleCount} stale ${staleCount === 1 ? "entry" : "entries"} found. Run \`qenv clean\` to remove.`
+        );
+      }
+    } catch (err) {
+      logger.error(err.message || String(err));
+      process.exitCode = 1;
+    }
+  });
+}
+
+// src/commands/diff.ts
+var import_chalk3 = __toESM(require("chalk"));
+var import_node_readline2 = require("readline");
+function confirm2(message) {
+  const rl = (0, import_node_readline2.createInterface)({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve4) => {
+    rl.question(`${message} (y/N) `, (answer) => {
+      rl.close();
+      resolve4(answer.toLowerCase() === "y" || answer.toLowerCase() === "yes");
+    });
+  });
+}
+function registerDiffCommand(program) {
+  program.command("diff").description("Compare manifest records with actual system values").option("--json", "Output as JSON").addHelpText("after", `
+Examples:
+  $ qenv diff
+  $ qenv diff --json
+`).action(async (options) => {
+    try {
+      const vars = manifest.getAll();
+      const entries = Object.entries(vars);
+      if (entries.length === 0) {
+        logger.info("No variables managed by qenv.");
+        return;
+      }
+      const driver = getSystemDriver();
+      const diffs = [];
+      for (const [name, entry] of entries) {
+        let currentValue;
+        if (entry.scope === "file" && entry.filePath) {
+          const fileDriver = getDotenvDriver(entry.filePath);
+          currentValue = await fileDriver.get(name);
+        } else {
+          currentValue = await driver.get(name);
+        }
+        if (currentValue === void 0) {
+          diffs.push({
+            name,
+            scope: entry.scope,
+            manifestStatus: "tracked",
+            currentValue: null,
+            status: "missing"
+          });
+        } else {
+          diffs.push({
+            name,
+            scope: entry.scope,
+            manifestStatus: "tracked",
+            currentValue,
+            status: "match"
+          });
+        }
+      }
+      if (options.json) {
+        logger.plain(JSON.stringify(diffs, null, 2));
+        return;
+      }
+      logger.plain("");
+      const rows = [];
+      for (const diff of diffs) {
+        let statusIcon;
+        switch (diff.status) {
+          case "match":
+            statusIcon = import_chalk3.default.green("\u2714 in sync");
+            break;
+          case "changed":
+            statusIcon = import_chalk3.default.yellow("~ changed");
+            break;
+          case "missing":
+            statusIcon = import_chalk3.default.red("\u2716 missing");
+            break;
+        }
+        rows.push([diff.name, diff.scope, statusIcon]);
+      }
+      logger.table(["NAME", "SCOPE", "STATUS"], rows);
+      logger.plain("");
+      const missingCount = diffs.filter((d) => d.status === "missing").length;
+      const changedCount = diffs.filter((d) => d.status === "changed").length;
+      if (missingCount > 0) {
+        logger.warn(`${missingCount} variable${missingCount > 1 ? "s" : ""} missing from system. Run \`qenv clean\` to remove stale entries.`);
+      }
+      if (changedCount > 0) {
+        logger.info(`${changedCount} variable${changedCount > 1 ? "s" : ""} changed since last set.`);
+      }
+      if (missingCount === 0 && changedCount === 0) {
+        logger.success("All variables are in sync.");
+      }
+    } catch (err) {
+      logger.error(err.message || String(err));
+      process.exitCode = 1;
+    }
+  });
+}
+function registerCleanCommand(program) {
+  program.command("clean").description("Remove stale entries from manifest").option("--force", "Skip confirmation prompt").addHelpText("after", `
+Examples:
+  $ qenv clean
+  $ qenv clean --force
+`).action(async (options) => {
+    try {
+      const vars = manifest.getAll();
+      const entries = Object.entries(vars);
+      if (entries.length === 0) {
+        logger.info("No variables managed by qenv.");
+        return;
+      }
+      const driver = getSystemDriver();
+      const staleNames = [];
+      for (const [name, entry] of entries) {
+        let currentValue;
+        if (entry.scope === "file" && entry.filePath) {
+          const fileDriver = getDotenvDriver(entry.filePath);
+          currentValue = await fileDriver.get(name);
+        } else {
+          currentValue = await driver.get(name);
+        }
+        if (currentValue === void 0) {
+          staleNames.push(name);
+        }
+      }
+      if (staleNames.length === 0) {
+        logger.success("No stale entries found. Everything is clean!");
+        return;
+      }
+      logger.plain("");
+      logger.info(`Found ${staleNames.length} stale ${staleNames.length === 1 ? "entry" : "entries"}:`);
+      for (const name of staleNames) {
+        logger.plain(`  ${import_chalk3.default.yellow("\u26A0")} ${name}`);
+      }
+      logger.plain("");
+      if (!options.force) {
+        const confirmed = await confirm2("Remove these stale entries from manifest?");
+        if (!confirmed) {
+          logger.info("Cancelled.");
+          return;
+        }
+      }
+      const removed = manifest.removeMany(staleNames);
+      logger.success(`Removed ${removed} stale ${removed === 1 ? "entry" : "entries"} from manifest.`);
+    } catch (err) {
+      logger.error(err.message || String(err));
+      process.exitCode = 1;
+    }
+  });
+}
+
+// src/commands/init.ts
+var import_node_fs3 = require("fs");
+var import_node_path2 = require("path");
+var SHELL_CONFIGS = {
+  bash: "~/.bashrc",
+  zsh: "~/.zshrc",
+  fish: "~/.config/fish/config.fish",
+  pwsh: "",
+  // Determined dynamically via $PROFILE
+  cmd: ""
+  // Not applicable
+};
+var WRAPPER_CODE = {
+  bash: `
+# qenv shell integration
+qenv() { eval "$(command qenv --shell-eval "$@")"; }
+# end qenv`,
+  zsh: `
+# qenv shell integration
+qenv() { eval "$(command qenv --shell-eval "$@")"; }
+# end qenv`,
+  fish: `
+# qenv shell integration
+function qenv
+  eval (command qenv --shell-eval $argv)
+end
+# end qenv`,
+  pwsh: `
+# qenv shell integration
+function qenv { $result = & qenv.cmd --shell-eval @args; if ($result) { Invoke-Expression $result } }
+# end qenv`,
+  cmd: ""
+};
+var WRAPPER_START = "# qenv shell integration";
+var WRAPPER_END = "# end qenv";
+function getConfigPath(shell) {
+  const home = getHomeDir();
+  if (!home) return null;
+  if (shell === "pwsh") {
+    const psProfile = process.env.PROFILE;
+    if (psProfile) return psProfile;
+    if (process.platform === "win32") {
+      return (0, import_node_path2.resolve)(process.env.USERPROFILE || home, "Documents", "PowerShell", "Microsoft.PowerShell_profile.ps1");
+    }
+    return (0, import_node_path2.resolve)(home, ".config", "powershell", "Microsoft.PowerShell_profile.ps1");
+  }
+  if (shell === "cmd") {
+    return null;
+  }
+  const configPath = SHELL_CONFIGS[shell];
+  return configPath ? configPath.replace("~", home) : null;
+}
+function registerInitCommand(program) {
+  program.command("init").description("Install shell integration for --local mode support").option("--shell <type>", "Specify shell type (bash/zsh/fish/pwsh)").option("--print", "Print wrapper code without installing").option("--uninstall", "Remove shell integration").addHelpText("after", `
+Examples:
+  $ qenv init
+  $ qenv init --shell zsh
+  $ qenv init --print
+  $ qenv init --uninstall
+`).action(async (options) => {
+    try {
+      const shell = options.shell || detectShell();
+      if (shell === "cmd") {
+        logger.error("Command Prompt (cmd) does not support shell integration.");
+        logger.info("Please use PowerShell instead.");
+        process.exitCode = 1;
+        return;
+      }
+      const wrapperCode = WRAPPER_CODE[shell];
+      if (!wrapperCode) {
+        logger.error(`Shell "${shell}" is not supported.`);
+        process.exitCode = 1;
+        return;
+      }
+      if (options.print) {
+        logger.info(`Add the following to your ${getShellName(shell)} config:
+`);
+        logger.plain(wrapperCode);
+        return;
+      }
+      const configPath = getConfigPath(shell);
+      if (!configPath) {
+        logger.error("Could not determine shell config file path.");
+        logger.info("Use --print to see the wrapper code and add it manually.");
+        process.exitCode = 1;
+        return;
+      }
+      if (options.uninstall) {
+        if (!(0, import_node_fs3.existsSync)(configPath)) {
+          logger.info("Shell config file not found. Nothing to uninstall.");
+          return;
+        }
+        let content2 = (0, import_node_fs3.readFileSync)(configPath, "utf-8");
+        const startIdx = content2.indexOf(WRAPPER_START);
+        const endIdx = content2.indexOf(WRAPPER_END);
+        if (startIdx === -1) {
+          logger.info("qenv shell integration not found. Nothing to uninstall.");
+          return;
+        }
+        const before = content2.slice(0, startIdx).trimEnd();
+        const after = content2.slice(endIdx + WRAPPER_END.length).trimStart();
+        content2 = before + (after ? "\n" + after : "") + "\n";
+        (0, import_node_fs3.writeFileSync)(configPath, content2, "utf-8");
+        logger.success(`Removed qenv integration from ${configPath}`);
+        logger.info("Restart your shell to apply changes.");
+        return;
+      }
+      let content = "";
+      if ((0, import_node_fs3.existsSync)(configPath)) {
+        content = (0, import_node_fs3.readFileSync)(configPath, "utf-8");
+        if (content.includes(WRAPPER_START)) {
+          logger.info("qenv shell integration is already installed.");
+          logger.info(`Config file: ${configPath}`);
+          return;
+        }
+      }
+      (0, import_node_fs3.appendFileSync)(configPath, "\n" + wrapperCode.trim() + "\n", "utf-8");
+      logger.success(`Installed qenv integration in ${configPath}`);
+      logger.info(`Shell: ${getShellName(shell)}`);
+      logger.info("Restart your shell or run:");
+      if (shell === "fish") {
+        logger.plain(`  source ${configPath}`);
+      } else if (shell === "pwsh") {
+        logger.plain(`  . $PROFILE`);
+      } else {
+        logger.plain(`  source ${configPath}`);
+      }
+    } catch (err) {
+      logger.error(err.message || String(err));
+      process.exitCode = 1;
+    }
+  });
+}
+
+// src/commands/import.ts
+var import_node_fs4 = require("fs");
+var import_node_path3 = require("path");
+var import_chalk4 = __toESM(require("chalk"));
+function registerImportCommand(program, isShellEval) {
+  program.command("import <file>").description("Import variables from a .env file").option("--local", "Import to current shell session (requires qenv init)").option("--dry-run", "Preview changes without applying").option("--overwrite", "Overwrite existing variables").addHelpText("after", `
+Examples:
+  $ qenv import .env
+  $ qenv import .env.prod --dry-run
+  $ qenv import .env --local
+  $ qenv import .env --overwrite
+`).action(async (file, options) => {
+    try {
+      const filePath = (0, import_node_path3.resolve)(process.cwd(), file);
+      if (!(0, import_node_fs4.existsSync)(filePath)) {
+        logger.error(`File not found: ${filePath}`);
+        process.exitCode = 1;
+        return;
+      }
+      const content = (0, import_node_fs4.readFileSync)(filePath, "utf-8");
+      const lines = content.split("\n");
+      const vars = {};
+      for (const line of lines) {
+        const parsed = parseDotEnvLine(line);
+        if (parsed) {
+          vars[parsed.key] = parsed.value;
+        }
+      }
+      const entries = Object.entries(vars);
+      if (entries.length === 0) {
+        logger.info(`No variables found in ${file}`);
+        return;
+      }
+      if (options.dryRun) {
+        logger.info(`Preview of import from ${file}:
+`);
+        for (const [key, value] of entries) {
+          logger.plain(`  ${import_chalk4.default.green("+")} ${key}=${value}`);
+        }
+        logger.plain(`
+  Total: ${entries.length} variable${entries.length > 1 ? "s" : ""}`);
+        return;
+      }
+      if (options.local) {
+        if (isShellEval) {
+          const shell = detectShell();
+          const evalParts = [];
+          for (const [key, value] of entries) {
+            const expressions = {
+              bash: `export ${key}="${value}"`,
+              zsh: `export ${key}="${value}"`,
+              fish: `set -gx ${key} "${value}"`,
+              pwsh: `$env:${key} = "${value}"`,
+              cmd: `set "${key}=${value}"`
+            };
+            evalParts.push(expressions[shell] || expressions["bash"]);
+          }
+          const separator = shell === "fish" ? "; " : "; ";
+          process.stdout.write(evalParts.join(separator));
+        } else {
+          logger.warn("--local requires qenv init. Run `qenv init` first.");
+        }
+        return;
+      }
+      const driver = getSystemDriver();
+      let imported = 0;
+      let skipped = 0;
+      for (const [key, value] of entries) {
+        if (!options.overwrite) {
+          const existing = await driver.get(key);
+          if (existing !== void 0) {
+            logger.warn(`Skipped ${key} (already exists). Use --overwrite to replace.`);
+            skipped++;
+            continue;
+          }
+        }
+        await driver.set(key, value);
+        manifest.set(key, "system");
+        imported++;
+      }
+      if (isShellEval) {
+        outputNoOp();
+      } else {
+        logger.success(`Imported ${imported} variable${imported > 1 ? "s" : ""} from ${file}`);
+        if (skipped > 0) {
+          logger.info(`Skipped ${skipped} existing variable${skipped > 1 ? "s" : ""}.`);
+        }
+      }
+    } catch (err) {
+      logger.error(err.message || String(err));
+      process.exitCode = 1;
+    }
+  });
+}
+function registerExportCommand(program) {
+  program.command("export [file]").description("Export variables to .env format").option("--all", "Export all system environment variables").option("--filter <prefix>", "Only export variables matching prefix").addHelpText("after", `
+Examples:
+  $ qenv export
+  $ qenv export .env.backup
+  $ qenv export --all
+  $ qenv export --filter REACT_APP_
+`).action(async (file, options) => {
+    try {
+      let vars = {};
+      if (options.all) {
+        const driver = getSystemDriver();
+        vars = await driver.list();
+      } else {
+        const manifestVars = manifest.getAll();
+        const driver = getSystemDriver();
+        for (const [name, entry] of Object.entries(manifestVars)) {
+          let value;
+          if (entry.scope === "file" && entry.filePath) {
+            const fileDriver = getDotenvDriver(entry.filePath);
+            value = await fileDriver.get(name);
+          } else {
+            value = await driver.get(name);
+          }
+          if (value !== void 0) {
+            vars[name] = value;
+          }
+        }
+      }
+      if (options.filter) {
+        const prefix2 = options.filter;
+        const filtered = {};
+        for (const [key, value] of Object.entries(vars)) {
+          if (key.startsWith(prefix2)) {
+            filtered[key] = value;
+          }
+        }
+        vars = filtered;
+      }
+      const entries = Object.entries(vars);
+      if (entries.length === 0) {
+        logger.info("No variables to export.");
+        return;
+      }
+      const output = serializeDotEnv(vars);
+      if (file) {
+        const outPath = (0, import_node_path3.resolve)(process.cwd(), file);
+        (0, import_node_fs4.writeFileSync)(outPath, output + "\n", "utf-8");
+        logger.success(`Exported ${entries.length} variable${entries.length > 1 ? "s" : ""} to ${file}`);
+      } else {
+        logger.plain(output);
+      }
+    } catch (err) {
+      logger.error(err.message || String(err));
+      process.exitCode = 1;
+    }
+  });
+}
+
+// src/index.ts
+var VERSION = "1.0.0";
+function isShellEvalMode() {
+  return process.argv.includes("--shell-eval");
+}
+function setupGlobals() {
+  if (process.argv.includes("--verbose")) {
+    process.env.QENV_VERBOSE = "1";
+  }
+  if (process.argv.includes("--no-color")) {
+    process.env.NO_COLOR = "1";
+    process.env.FORCE_COLOR = "0";
+  }
+  if (process.argv.includes("--silent")) {
+    const originalLog = console.log;
+    const originalInfo = console.info;
+    console.log = () => {
+    };
+    console.info = () => {
+    };
+  }
+}
+function main() {
+  setupGlobals();
+  const shellEval = isShellEvalMode();
+  const argv = process.argv.filter((arg) => arg !== "--shell-eval");
+  const program = new import_commander.Command();
+  program.name("qenv").version(VERSION, "-V, --version", "Output the version number").description(`${import_chalk5.default.bold(`qenv v${VERSION}`)} \u2014 Cross-platform env var manager`).option("--no-color", "Disable colored output").option("--silent", "Suppress all stdout output (errors only)").option("--verbose", "Output debug information").addHelpText("after", `
+Run ${import_chalk5.default.cyan("qenv <command> --help")} for detailed usage of each command.
+`);
+  registerSetCommand(program, shellEval);
+  registerGetCommand(program);
+  registerRemoveCommand(program, shellEval);
+  registerListCommand(program);
+  registerDiffCommand(program);
+  registerCleanCommand(program);
+  registerInitCommand(program);
+  registerImportCommand(program, shellEval);
+  registerExportCommand(program);
+  program.parse(argv);
+}
+main();
+//# sourceMappingURL=index.js.map