lecoffre 0.2.0 → 0.2.1

package/dist/lecoffre.js

@@ -0,0 +1,856 @@
+#!/usr/bin/env node
+
+// bin/lecoffre.ts
+import { parse as parse2 } from "@bomb.sh/args";
+
+// package.json
+var package_default = {
+  name: "lecoffre",
+  version: "0.2.1",
+  description: "Work in progress CLI project.",
+  repository: {
+    type: "git",
+    url: "https://github.com/hsablonniere/lecoffre"
+  },
+  bin: {
+    lecoffre: "./dist/lecoffre.js"
+  },
+  files: [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  type: "module",
+  scripts: {
+    dev: "node bin/lecoffre.ts",
+    test: "vitest run",
+    lint: "oxlint . --vitest-plugin --deny-warnings",
+    "lint:fix": "oxlint . --vitest-plugin --deny-warnings --fix",
+    format: "oxfmt . --write",
+    "format:check": "oxfmt . --check",
+    typecheck: "tsgo --noEmit",
+    build: "esbuild bin/lecoffre.ts --bundle --platform=node --format=esm --packages=external --outfile=dist/lecoffre.js",
+    check: "pnpm lint && pnpm format:check && pnpm typecheck && pnpm test",
+    changeset: "changeset",
+    "version-packages": "changeset version",
+    prepack: "pnpm build",
+    release: "changeset publish"
+  },
+  dependencies: {
+    "@bomb.sh/args": "^0.3.1",
+    zod: "^4.3.6"
+  },
+  devDependencies: {
+    "@changesets/changelog-github": "^0.5.2",
+    "@changesets/cli": "^2.29.8",
+    "@types/node": "^25.2.3",
+    "@typescript/native-preview": "^7.0.0-dev.20260217.1",
+    esbuild: "^0.27.4",
+    execa: "^9.6.1",
+    oxfmt: "^0.33.0",
+    oxlint: "^1.48.0",
+    vitest: "^4.0.18"
+  },
+  engines: {
+    node: ">=24"
+  }
+};
+
+// src/commands/import.command.ts
+import { basename } from "node:path";
+import { realpath } from "node:fs/promises";
+import { parseEnv } from "node:util";
+import { z as z3 } from "zod";
+
+// src/lib/define-command.ts
+function defineCommand(definition) {
+  return definition;
+}
+
+// src/lib/define-option.ts
+function defineOption(definition) {
+  return definition;
+}
+
+// src/lib/json-storage.ts
+import { readFile, writeFile } from "node:fs/promises";
+
+// src/lib/storage.ts
+var ProjectNotFoundError = class extends Error {
+  project;
+  constructor(project) {
+    super(`Project not found: ${project}`);
+    this.name = "ProjectNotFoundError";
+    this.project = project;
+  }
+};
+var EnvironmentNotFoundError = class extends Error {
+  project;
+  environment;
+  constructor(project, environment) {
+    super(`Environment not found: ${environment}`);
+    this.name = "EnvironmentNotFoundError";
+    this.project = project;
+    this.environment = environment;
+  }
+};
+var StorageNotInitializedError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "StorageNotInitializedError";
+  }
+};
+var Storage = class {
+};
+
+// src/lib/json-storage.ts
+var JsonStorage = class extends Storage {
+  filePath;
+  constructor(filePath) {
+    super();
+    this.filePath = filePath;
+  }
+  async read() {
+    try {
+      const content = await readFile(this.filePath, "utf-8");
+      return JSON.parse(content);
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        return {};
+      }
+      throw error;
+    }
+  }
+  async write(data) {
+    await writeFile(this.filePath, JSON.stringify(data, null, 2) + "\n");
+  }
+  async getProjects() {
+    const data = await this.read();
+    return Object.keys(data);
+  }
+  async getProject(project) {
+    const data = await this.read();
+    const projectData = data[project];
+    if (projectData === void 0) {
+      throw new ProjectNotFoundError(project);
+    }
+    return Object.fromEntries(Object.entries(projectData).map(([env, vars]) => [env, { ...vars }]));
+  }
+  async init() {
+  }
+  async setVariables(project, env, vars) {
+    const data = await this.read();
+    if (data[project] === void 0) {
+      data[project] = {};
+    }
+    data[project][env] = vars;
+    await this.write(data);
+  }
+  async deleteEnvironment(project, env) {
+    const data = await this.read();
+    const projectData = data[project];
+    if (projectData !== void 0) {
+      delete projectData[env];
+      if (Object.keys(projectData).length === 0) {
+        delete data[project];
+      }
+      await this.write(data);
+    }
+  }
+  async deleteProject(project) {
+    const data = await this.read();
+    delete data[project];
+    await this.write(data);
+  }
+};
+
+// src/lib/one-password-storage.ts
+import { execFile as execFileCb } from "node:child_process";
+import { promisify } from "node:util";
+function hasStderr(error) {
+  return typeof error === "object" && error !== null && "stderr" in error;
+}
+function getStderr(error) {
+  return hasStderr(error) ? error.stderr?.trim() ?? "" : "";
+}
+function isItemNotFound(error) {
+  return /isn't an item/i.test(getStderr(error));
+}
+function isVaultNotFound(error) {
+  return /isn't a vault/i.test(getStderr(error));
+}
+var execFile = promisify(execFileCb);
+async function execOp(...args) {
+  try {
+    const { stdout } = await execFile("op", args);
+    return stdout;
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      throw new Error(
+        "1Password CLI (op) is not installed. See https://developer.1password.com/docs/cli/get-started/"
+      );
+    }
+    throw error;
+  }
+}
+var VAULT = "lecoffre";
+var OnePasswordStorage = class extends Storage {
+  vault;
+  constructor(vault = VAULT) {
+    super();
+    this.vault = vault;
+  }
+  rethrow(error) {
+    if (isVaultNotFound(error)) {
+      throw new StorageNotInitializedError(
+        `Vault "${this.vault}" not found. Run "lecoffre init" to create it.`
+      );
+    }
+    const stderr = getStderr(error);
+    if (stderr !== "") {
+      throw new Error(stderr);
+    }
+    throw error;
+  }
+  async init() {
+    try {
+      await execOp("vault", "get", this.vault, "--format", "json");
+    } catch (error) {
+      if (isVaultNotFound(error)) {
+        await execOp("vault", "create", this.vault);
+        return;
+      }
+      throw error;
+    }
+  }
+  async getItem(project) {
+    try {
+      const stdout = await execOp(
+        "item",
+        "get",
+        project,
+        "--vault",
+        this.vault,
+        "--format",
+        "json"
+      );
+      return JSON.parse(stdout);
+    } catch (error) {
+      if (isItemNotFound(error)) return null;
+      return this.rethrow(error);
+    }
+  }
+  /**
+   * Return only user-defined fields. 1Password items include system fields
+   * (e.g. "notesPlain") that have a `purpose` property set. User-created
+   * fields never have `purpose`, so we use that to distinguish them.
+   */
+  getUserFields(fields) {
+    return fields.filter(
+      (field) => field.purpose === void 0 && field.section?.label !== void 0
+    );
+  }
+  async getProjects() {
+    try {
+      const stdout = await execOp("item", "list", "--vault", this.vault, "--format", "json");
+      const items = JSON.parse(stdout);
+      return items.map((item) => item.title);
+    } catch (error) {
+      return this.rethrow(error);
+    }
+  }
+  async getProject(project) {
+    const item = await this.getItem(project);
+    if (item === null) {
+      throw new ProjectNotFoundError(project);
+    }
+    const envs = {};
+    for (const field of this.getUserFields(item.fields)) {
+      const sectionLabel = field.section?.label;
+      if (sectionLabel !== void 0) {
+        envs[sectionLabel] ??= {};
+        envs[sectionLabel][field.label] = field.value;
+      }
+    }
+    return envs;
+  }
+  // Note: field values are passed as process arguments and are briefly visible
+  // in /proc/<pid>/cmdline. The 1Password CLI does not support reading field
+  // values from stdin when spawned as a child process (only shell pipes work).
+  async setVariables(project, env, vars) {
+    const item = await this.getItem(project);
+    if (item === null) {
+      const fieldAssignments = Object.entries(vars).map(
+        ([key, value]) => `${env}.${key}[concealed]=${value}`
+      );
+      await execOp(
+        "item",
+        "create",
+        "--vault",
+        this.vault,
+        "--category",
+        "Secure Note",
+        "--title",
+        project,
+        ...fieldAssignments
+      );
+      return;
+    }
+    const operations = [];
+    for (const field of this.getUserFields(item.fields)) {
+      if (field.section?.label === env) {
+        operations.push(`${env}.${field.label}[delete]`);
+      }
+    }
+    for (const [key, value] of Object.entries(vars)) {
+      operations.push(`${env}.${key}[concealed]=${value}`);
+    }
+    if (operations.length > 0) {
+      await execOp("item", "edit", project, "--vault", this.vault, ...operations);
+    }
+  }
+  async deleteEnvironment(project, env) {
+    const item = await this.getItem(project);
+    if (item === null) {
+      return;
+    }
+    const userFields = this.getUserFields(item.fields);
+    const sections = /* @__PURE__ */ new Set();
+    const fieldsToDelete = [];
+    for (const field of userFields) {
+      if (field.section?.label !== void 0) {
+        sections.add(field.section.label);
+      }
+      if (field.section?.label === env) {
+        fieldsToDelete.push(`${env}.${field.label}[delete]`);
+      }
+    }
+    if (fieldsToDelete.length === 0) {
+      return;
+    }
+    if (sections.size <= 1 && sections.has(env)) {
+      await execOp("item", "delete", project, "--vault", this.vault);
+      return;
+    }
+    await execOp("item", "edit", project, "--vault", this.vault, ...fieldsToDelete);
+  }
+  async deleteProject(project) {
+    try {
+      await execOp("item", "delete", project, "--vault", this.vault);
+    } catch (error) {
+      if (isItemNotFound(error)) return;
+      this.rethrow(error);
+    }
+  }
+};
+
+// src/lib/get-storage.ts
+function getStorage() {
+  const storagePath = process.env.LECOFFRE_STORAGE_PATH;
+  if (storagePath !== void 0) {
+    return new JsonStorage(storagePath);
+  }
+  return new OnePasswordStorage();
+}
+
+// src/options/environment.option.ts
+import { z } from "zod";
+var environmentOption = defineOption({
+  name: "environment",
+  schema: z.string().default("default"),
+  description: "Environment name",
+  aliases: ["e"],
+  placeholder: "env"
+});
+
+// src/options/project.option.ts
+import { z as z2 } from "zod";
+var projectOption = defineOption({
+  name: "project",
+  schema: z2.string().refine((val) => !val.startsWith("-"), { message: 'must not start with "-"' }).optional(),
+  description: "Project name",
+  aliases: ["p"],
+  placeholder: "name"
+});
+
+// src/commands/import.command.ts
+var importCommand = defineCommand({
+  description: "Import variables from stdin (.env format)",
+  options: {
+    project: projectOption,
+    environment: environmentOption,
+    merge: defineOption({
+      name: "merge",
+      schema: z3.boolean().default(false),
+      description: "Merge with existing variables instead of replacing",
+      aliases: ["m"]
+    })
+  },
+  async handler(options) {
+    const storage = getStorage();
+    const project = options.project ?? basename(await realpath(process.cwd()));
+    const input = await readStdin();
+    const newVars = parseEnv(input);
+    let existingVars;
+    try {
+      const projectData = await storage.getProject(project);
+      existingVars = projectData[options.environment] ?? {};
+    } catch (error) {
+      if (error instanceof ProjectNotFoundError) {
+        existingVars = {};
+      } else {
+        throw error;
+      }
+    }
+    const added = [];
+    const updated = [];
+    const removed = [];
+    if (options.merge) {
+      for (const key of Object.keys(newVars)) {
+        if (key in existingVars) {
+          if (existingVars[key] !== newVars[key]) {
+            updated.push(key);
+          }
+        } else {
+          added.push(key);
+        }
+      }
+      await storage.setVariables(project, options.environment, { ...existingVars, ...newVars });
+    } else {
+      for (const key of Object.keys(newVars)) {
+        if (key in existingVars) {
+          if (existingVars[key] !== newVars[key]) {
+            updated.push(key);
+          }
+        } else {
+          added.push(key);
+        }
+      }
+      for (const key of Object.keys(existingVars)) {
+        if (!(key in newVars)) {
+          removed.push(key);
+        }
+      }
+      await storage.setVariables(project, options.environment, newVars);
+    }
+    for (const key of added) {
+      console.error(`+ ${key} (added)`);
+    }
+    for (const key of updated) {
+      console.error(`~ ${key} (updated)`);
+    }
+    for (const key of removed) {
+      console.error(`- ${key} (removed)`);
+    }
+    const totalVars = Object.keys(newVars).length;
+    console.error(
+      `Imported ${totalVars} variable${totalVars !== 1 ? "s" : ""} into ${project} [${options.environment}]`
+    );
+  }
+});
+async function readStdin() {
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(chunk);
+  }
+  return Buffer.concat(chunks).toString("utf-8");
+}
+
+// src/commands/init.command.ts
+var initCommand = defineCommand({
+  description: "Initialize the storage backend",
+  async handler() {
+    const storage = getStorage();
+    await storage.init();
+    console.log("Storage initialized.");
+  }
+});
+
+// src/commands/list.command.ts
+var listCommand = defineCommand({
+  description: "List projects and their environments",
+  options: {
+    project: projectOption
+  },
+  async handler(options) {
+    const storage = getStorage();
+    if (options.project !== void 0) {
+      let projectData;
+      try {
+        projectData = await storage.getProject(options.project);
+      } catch (error) {
+        if (error instanceof ProjectNotFoundError) {
+          throw new Error(`Project not found: ${options.project}`);
+        }
+        throw error;
+      }
+      for (const [env, vars] of Object.entries(projectData)) {
+        const count = Object.keys(vars).length;
+        console.log(`${env} (${count} variable${count !== 1 ? "s" : ""})`);
+      }
+      return;
+    }
+    const projects = await storage.getProjects();
+    if (projects.length === 0) {
+      console.log("No projects found.");
+      return;
+    }
+    for (const p of projects) {
+      console.log(p);
+      const projectData = await storage.getProject(p);
+      for (const [env, vars] of Object.entries(projectData)) {
+        const count = Object.keys(vars).length;
+        console.log(`  ${env} (${count} variable${count !== 1 ? "s" : ""})`);
+      }
+    }
+  }
+});
+
+// src/commands/load.command.ts
+import { basename as basename3 } from "node:path";
+import { realpath as realpath2 } from "node:fs/promises";
+
+// src/lib/shell.ts
+import { execFileSync } from "node:child_process";
+import { basename as basename2 } from "node:path";
+var SUPPORTED_SHELLS = ["bash", "zsh", "fish"];
+function isSupportedShell(name2) {
+  return SUPPORTED_SHELLS.includes(name2);
+}
+function detectShell() {
+  const name2 = basename2(
+    execFileSync("ps", ["-p", String(process.ppid), "-o", "comm="], { encoding: "utf-8" }).trim()
+  );
+  if (isSupportedShell(name2)) {
+    return name2;
+  }
+  throw new Error(`Unsupported shell: ${name2}`);
+}
+function formatVariables(shell, vars) {
+  const lines = Object.entries(vars).map(([key, value]) => formatSingleVariable(shell, key, value));
+  return lines.join("\n");
+}
+function formatSingleVariable(shell, key, value) {
+  if (shell === "fish") {
+    return `set -gx ${key} '${escapeSingleQuotes(value, "fish")}'`;
+  }
+  return `export ${key}='${escapeSingleQuotes(value, "posix")}'`;
+}
+function formatUnsetVariables(shell, keys) {
+  const lines = keys.map((key) => formatSingleUnsetVariable(shell, key));
+  return lines.join("\n");
+}
+function formatSingleUnsetVariable(shell, key) {
+  if (shell === "fish") {
+    return `set -e ${key}`;
+  }
+  return `unset ${key}`;
+}
+function escapeSingleQuotes(value, mode) {
+  if (mode === "fish") {
+    return value.replaceAll("\\", "\\\\").replaceAll("'", "\\'");
+  }
+  return value.replaceAll("'", "'\\''");
+}
+
+// src/commands/load.command.ts
+var loadCommand = defineCommand({
+  description: "Load variables into the current shell environment",
+  options: {
+    project: projectOption,
+    environment: environmentOption
+  },
+  async handler(options) {
+    const storage = getStorage();
+    const project = options.project ?? basename3(await realpath2(process.cwd()));
+    const projectData = await storage.getProject(project);
+    const vars = projectData[options.environment];
+    if (vars === void 0) {
+      throw new EnvironmentNotFoundError(project, options.environment);
+    }
+    const shell = detectShell();
+    const output = formatVariables(shell, vars);
+    if (output !== "") {
+      console.log(output);
+    }
+  }
+});
+
+// src/commands/unload.command.ts
+import { basename as basename4 } from "node:path";
+import { realpath as realpath3 } from "node:fs/promises";
+var unloadCommand = defineCommand({
+  description: "Unload variables from the current shell environment",
+  options: {
+    project: projectOption,
+    environment: environmentOption
+  },
+  async handler(options) {
+    const storage = getStorage();
+    const project = options.project ?? basename4(await realpath3(process.cwd()));
+    const projectData = await storage.getProject(project);
+    const vars = projectData[options.environment];
+    if (vars === void 0) {
+      throw new EnvironmentNotFoundError(project, options.environment);
+    }
+    const shell = detectShell();
+    const output = formatUnsetVariables(shell, Object.keys(vars));
+    if (output !== "") {
+      console.log(output);
+    }
+  }
+});
+
+// src/lib/format.ts
+import { styleText } from "node:util";
+
+// src/lib/zod-utils.ts
+function getDef(schema) {
+  return schema._zod.def;
+}
+function isBoolean(schema) {
+  const def = getDef(schema);
+  if (def.type === "boolean") return true;
+  if (def.type === "default" || def.type === "optional" || def.type === "nullable") {
+    if (def.innerType !== void 0) return isBoolean(def.innerType);
+  }
+  return false;
+}
+function isRequired(schema) {
+  const def = getDef(schema);
+  if (def.type === "default" || def.type === "optional" || def.type === "nullable") {
+    return false;
+  }
+  if (def.type === "pipe" && def.in !== void 0) {
+    return isRequired(def.in);
+  }
+  return true;
+}
+function getDefault(schema) {
+  let current = schema;
+  while (current !== void 0) {
+    const def = getDef(current);
+    if (def.type === "default") return def.defaultValue;
+    if (def.type === "optional" || def.type === "nullable") {
+      current = def.innerType;
+      continue;
+    }
+    if (def.type === "pipe") {
+      current = def.in;
+      continue;
+    }
+    break;
+  }
+  return void 0;
+}
+
+// src/lib/format.ts
+function formatGlobalHelp(toolName, commands2) {
+  const names = Object.keys(commands2);
+  const sections = [styleText("bold", "USAGE"), `  ${toolName} <command> [options]`];
+  if (names.length > 0) {
+    const longest = Math.max(...names.map((n) => n.length));
+    const commandList = names.map((name2) => `  ${name2.padEnd(longest)}  ${commands2[name2].description}`).join("\n");
+    sections.push("", styleText("bold", "COMMANDS"), commandList);
+  }
+  return sections.join("\n");
+}
+function formatCommandHelp(toolName, commandName2, command2) {
+  const sections = [
+    styleText("bold", "USAGE"),
+    formatUsageLine(toolName, commandName2, command2)
+  ];
+  const argList = formatArgList(command2.args ?? []);
+  if (argList !== null) {
+    sections.push("", styleText("bold", "ARGUMENTS"), argList);
+  }
+  const optionList = formatOptionList(command2.options ?? {});
+  if (optionList !== null) {
+    sections.push("", styleText("bold", "OPTIONS"), optionList);
+  }
+  return sections.join("\n");
+}
+function formatUsageLine(toolName, commandName2, command2) {
+  const argPlaceholders = (command2.args ?? []).map((a) => `<${a.placeholder}>`).join(" ");
+  const parts = [toolName, commandName2];
+  if (argPlaceholders !== "") parts.push(argPlaceholders);
+  parts.push("[options]");
+  return `  ${parts.join(" ")}`;
+}
+function formatArgList(args) {
+  if (args.length === 0) return null;
+  const lines = args.map((arg) => ({
+    left: `  ${arg.placeholder}`,
+    description: formatArgDescription(arg.description, arg.schema)
+  }));
+  const longest = Math.max(...lines.map((l) => l.left.length));
+  return lines.map((l) => `${l.left.padEnd(longest)}  ${l.description}`).join("\n");
+}
+function formatOptionList(options) {
+  const entries = Object.values(options);
+  if (entries.length === 0) return null;
+  const aliasPrefixes = entries.map((opt) => {
+    const aliases = opt.aliases ?? [];
+    return aliases.length > 0 ? aliases.map((a) => `-${a}`).join(", ") + ", " : "";
+  });
+  const longestAlias = Math.max(...aliasPrefixes.map((p) => p.length));
+  const lines = entries.map((opt, i) => {
+    const aliasPrefix = aliasPrefixes[i].padStart(longestAlias);
+    const placeholder = opt.placeholder ?? opt.name;
+    const flag = isBoolean(opt.schema) ? `--${opt.name}` : `--${opt.name} <${placeholder}>`;
+    return {
+      left: `  ${aliasPrefix}${flag}`,
+      description: formatDescription(opt.description, opt.schema)
+    };
+  });
+  const longest = Math.max(...lines.map((l) => l.left.length));
+  return lines.map((l) => `${l.left.padEnd(longest)}  ${l.description}`).join("\n");
+}
+function formatArgDescription(description, schema) {
+  const defaultValue = getDefault(schema);
+  if (defaultValue !== void 0) return `${description} (default: ${String(defaultValue)})`;
+  return isRequired(schema) ? description : `${description} (optional)`;
+}
+function formatDescription(description, schema) {
+  if (isRequired(schema)) return `${description} (required)`;
+  const defaultValue = getDefault(schema);
+  return defaultValue === void 0 ? description : `${description} (default: ${String(defaultValue)})`;
+}
+function formatErrors(errors) {
+  const errorLines = errors.map((e) => `  ${e}`).join("\n");
+  return `${styleText("bold", "ERRORS")}
+${errorLines}`;
+}
+
+// src/lib/parse-command.ts
+import { parse } from "@bomb.sh/args";
+import { ZodError } from "zod";
+var CommandValidationError = class extends Error {
+  errors;
+  constructor(errors) {
+    super(errors.join("\n"));
+    this.errors = errors;
+  }
+};
+var CommandHelpRequested = class extends Error {
+  constructor() {
+    super("Help requested");
+  }
+};
+function parseCommand(argv, command2) {
+  const commandOptions = command2.options ?? {};
+  const commandArgs = command2.args ?? [];
+  const parseOpts = buildParseOptions(commandOptions);
+  const raw = parse(argv, parseOpts);
+  if (raw["help"]) {
+    throw new CommandHelpRequested();
+  }
+  const errors = [];
+  const options = {};
+  for (const [key, opt] of Object.entries(commandOptions)) {
+    const rawValue = raw[opt.name];
+    try {
+      if (rawValue !== void 0) {
+        options[key] = opt.schema.parse(rawValue);
+      } else {
+        options[key] = opt.schema.parse(void 0);
+      }
+    } catch (error) {
+      if (error instanceof ZodError) {
+        for (const issue of error.issues) {
+          errors.push(`option "--${opt.name}": ${issue.message}`);
+        }
+      } else {
+        throw error;
+      }
+    }
+  }
+  const args = [];
+  for (let i = 0; i < commandArgs.length; i++) {
+    const argDef = commandArgs[i];
+    const rawValue = raw._[i];
+    try {
+      if (rawValue !== void 0) {
+        args.push(argDef.schema.parse(String(rawValue)));
+      } else {
+        args.push(argDef.schema.parse(void 0));
+      }
+    } catch (error) {
+      if (error instanceof ZodError) {
+        for (const issue of error.issues) {
+          errors.push(`argument <${argDef.placeholder}>: ${issue.message}`);
+        }
+      } else {
+        throw error;
+      }
+    }
+  }
+  if (errors.length > 0) {
+    throw new CommandValidationError(errors);
+  }
+  return { options, args };
+}
+function buildParseOptions(options) {
+  const boolean = [];
+  const string = [];
+  const alias = {};
+  for (const opt of Object.values(options)) {
+    if (isBoolean(opt.schema)) {
+      boolean.push(opt.name);
+    } else {
+      string.push(opt.name);
+    }
+    if (opt.aliases !== void 0) {
+      for (const a of opt.aliases) {
+        alias[a] = opt.name;
+      }
+    }
+  }
+  boolean.push("help");
+  alias["h"] = "help";
+  return { boolean, string, alias };
+}
+
+// bin/lecoffre.ts
+var { name } = package_default;
+var commands = {
+  init: initCommand,
+  list: listCommand,
+  load: loadCommand,
+  unload: unloadCommand,
+  import: importCommand
+};
+var initial = parse2(process.argv.slice(2));
+var [commandNameRaw] = initial._;
+if (commandNameRaw === void 0) {
+  console.log(formatGlobalHelp(name, commands));
+  process.exit(0);
+}
+var commandName = String(commandNameRaw);
+var command = commands[commandName];
+if (command === void 0) {
+  console.error(`Unknown command "${commandName}" for "${name}"
+`);
+  console.error(formatGlobalHelp(name, commands));
+  process.exit(1);
+}
+try {
+  const { options, args } = parseCommand(process.argv.slice(3), command);
+  await command.handler(options, ...args);
+} catch (error) {
+  if (error instanceof CommandHelpRequested) {
+    console.log(formatCommandHelp(name, commandName, command));
+    process.exit(0);
+  }
+  if (error instanceof CommandValidationError) {
+    console.error(formatErrors(error.errors) + "\n");
+    console.error(formatCommandHelp(name, commandName, command));
+    process.exit(1);
+  }
+  if (error instanceof Error) {
+    console.error(error.message);
+    process.exit(1);
+  }
+  console.error("An unexpected error occurred");
+  process.exit(1);
+}