lecoffre 0.2.0 → 0.2.1

package/package.json

@@ -1,17 +1,16 @@
 {
   "name": "lecoffre",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "Work in progress CLI project.",
   "repository": {
     "type": "git",
     "url": "https://github.com/hsablonniere/lecoffre"
   },
   "bin": {
-    "lecoffre": "./bin/lecoffre.ts"
+    "lecoffre": "./dist/lecoffre.js"
   },
   "files": [
-    "bin",
-    "src",
+    "dist",
     "README.md",
     "LICENSE"
   ],
@@ -25,6 +24,7 @@
     "@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",
@@ -41,6 +41,7 @@
     "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",

package/bin/lecoffre.ts

@@ -1,63 +0,0 @@
-#!/usr/bin/env node
-
-import { parse } from "@bomb.sh/args";
-import packageJson from "../package.json" with { type: "json" };
-import { importCommand } from "../src/commands/import.command.ts";
-import { initCommand } from "../src/commands/init.command.ts";
-import { listCommand } from "../src/commands/list.command.ts";
-import { loadCommand } from "../src/commands/load.command.ts";
-import { unloadCommand } from "../src/commands/unload.command.ts";
-import type { AnyCommandDefinition } from "../src/lib/define-command.ts";
-import { formatCommandHelp, formatErrors, formatGlobalHelp } from "../src/lib/format.ts";
-import {
-  CommandHelpRequested,
-  CommandValidationError,
-  parseCommand,
-} from "../src/lib/parse-command.ts";
-
-const { name } = packageJson;
-const commands: Record<string, AnyCommandDefinition> = {
-  init: initCommand,
-  list: listCommand,
-  load: loadCommand,
-  unload: unloadCommand,
-  import: importCommand,
-};
-
-const initial = parse(process.argv.slice(2));
-const [commandNameRaw] = initial._;
-
-if (commandNameRaw === undefined) {
-  console.log(formatGlobalHelp(name, commands));
-  process.exit(0);
-}
-
-const commandName = String(commandNameRaw);
-const command = commands[commandName];
-
-if (command === undefined) {
-  console.error(`Unknown command "${commandName}" for "${name}"\n`);
-  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);
-}

package/src/commands/import.command.ts

@@ -1,101 +0,0 @@
-import { basename } from "node:path";
-import { realpath } from "node:fs/promises";
-import { parseEnv } from "node:util";
-import { z } from "zod";
-import { defineCommand } from "../lib/define-command.ts";
-import { defineOption } from "../lib/define-option.ts";
-import { getStorage } from "../lib/get-storage.ts";
-import { environmentOption } from "../options/environment.option.ts";
-import { projectOption } from "../options/project.option.ts";
-import { ProjectNotFoundError } from "../lib/storage.ts";
-
-export const importCommand = defineCommand({
-  description: "Import variables from stdin (.env format)",
-  options: {
-    project: projectOption,
-    environment: environmentOption,
-    merge: defineOption({
-      name: "merge",
-      schema: z.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) as Record<string, string>;
-
-    let existingVars: Record<string, string>;
-    try {
-      const projectData = await storage.getProject(project);
-      existingVars = projectData[options.environment] ?? {};
-    } catch (error) {
-      if (error instanceof ProjectNotFoundError) {
-        existingVars = {};
-      } else {
-        throw error;
-      }
-    }
-
-    const added: Array<string> = [];
-    const updated: Array<string> = [];
-    const removed: Array<string> = [];
-
-    if (options.merge) {
-      // Merge mode: add/overwrite without clearing
-      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 {
-      // Replace mode: clear then set
-      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(): Promise<string> {
-  const chunks: Array<Buffer> = [];
-  for await (const chunk of process.stdin) {
-    chunks.push(chunk as Buffer);
-  }
-  return Buffer.concat(chunks).toString("utf-8");
-}

package/src/commands/init.command.ts

@@ -1,11 +0,0 @@
-import { defineCommand } from "../lib/define-command.ts";
-import { getStorage } from "../lib/get-storage.ts";
-
-export const initCommand = defineCommand({
-  description: "Initialize the storage backend",
-  async handler() {
-    const storage = getStorage();
-    await storage.init();
-    console.log("Storage initialized.");
-  },
-});

package/src/commands/list.command.ts

@@ -1,47 +0,0 @@
-import { defineCommand } from "../lib/define-command.ts";
-import { getStorage } from "../lib/get-storage.ts";
-import { projectOption } from "../options/project.option.ts";
-import { ProjectNotFoundError } from "../lib/storage.ts";
-
-export const listCommand = defineCommand({
-  description: "List projects and their environments",
-  options: {
-    project: projectOption,
-  },
-  async handler(options) {
-    const storage = getStorage();
-
-    if (options.project !== undefined) {
-      let projectData: Record<string, Record<string, string>>;
-      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" : ""})`);
-      }
-    }
-  },
-});

package/src/commands/load.command.ts

@@ -1,32 +0,0 @@
-import { basename } from "node:path";
-import { realpath } from "node:fs/promises";
-import { defineCommand } from "../lib/define-command.ts";
-import { getStorage } from "../lib/get-storage.ts";
-import { detectShell, formatVariables } from "../lib/shell.ts";
-import { EnvironmentNotFoundError } from "../lib/storage.ts";
-import { environmentOption } from "../options/environment.option.ts";
-import { projectOption } from "../options/project.option.ts";
-
-export const 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 ?? basename(await realpath(process.cwd()));
-
-    const projectData = await storage.getProject(project);
-    const vars = projectData[options.environment];
-    if (vars === undefined) {
-      throw new EnvironmentNotFoundError(project, options.environment);
-    }
-
-    const shell = detectShell();
-    const output = formatVariables(shell, vars);
-    if (output !== "") {
-      console.log(output);
-    }
-  },
-});

package/src/commands/unload.command.ts

@@ -1,32 +0,0 @@
-import { basename } from "node:path";
-import { realpath } from "node:fs/promises";
-import { defineCommand } from "../lib/define-command.ts";
-import { getStorage } from "../lib/get-storage.ts";
-import { detectShell, formatUnsetVariables } from "../lib/shell.ts";
-import { EnvironmentNotFoundError } from "../lib/storage.ts";
-import { environmentOption } from "../options/environment.option.ts";
-import { projectOption } from "../options/project.option.ts";
-
-export const 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 ?? basename(await realpath(process.cwd()));
-
-    const projectData = await storage.getProject(project);
-    const vars = projectData[options.environment];
-    if (vars === undefined) {
-      throw new EnvironmentNotFoundError(project, options.environment);
-    }
-
-    const shell = detectShell();
-    const output = formatUnsetVariables(shell, Object.keys(vars));
-    if (output !== "") {
-      console.log(output);
-    }
-  },
-});

package/src/lib/define-argument.ts

@@ -1,13 +0,0 @@
-import type { z } from "zod";
-
-export interface ArgumentDefinition<S extends z.ZodType = z.ZodType> {
-  schema: S;
-  description: string;
-  placeholder: string;
-}
-
-export function defineArgument<S extends z.ZodType>(
-  definition: ArgumentDefinition<S>,
-): ArgumentDefinition<S> {
-  return definition;
-}

package/src/lib/define-command.ts

@@ -1,43 +0,0 @@
-import type { z } from "zod";
-import type { ArgumentDefinition } from "./define-argument.ts";
-import type { OptionDefinition } from "./define-option.ts";
-
-type OptionsRecord = Record<string, OptionDefinition>;
-type ArgumentsArray = readonly ArgumentDefinition[];
-
-type InferOptionsType<O> = O extends OptionsRecord
-  ? { [K in keyof O]: z.infer<O[K]["schema"]> }
-  : Record<string, never>;
-
-type InferArgsType<A extends ArgumentsArray> = {
-  [K in keyof A]: A[K] extends ArgumentDefinition ? z.infer<A[K]["schema"]> : never;
-};
-
-type CommandHandler<O, A> = A extends ArgumentsArray
-  ? (options: InferOptionsType<O>, ...args: InferArgsType<A>) => void | Promise<void>
-  : (options: InferOptionsType<O>) => void | Promise<void>;
-
-export interface CommandDefinition<
-  O extends OptionsRecord | undefined = OptionsRecord,
-  A extends ArgumentsArray | undefined = ArgumentsArray,
-> {
-  description: string;
-  options?: O | undefined;
-  args?: A | undefined;
-  handler: CommandHandler<O, A>;
-}
-
-/** Type-erased command definition for use in registries. */
-export interface AnyCommandDefinition {
-  description: string;
-  options?: OptionsRecord | undefined;
-  args?: ArgumentsArray | undefined;
-  handler: (options: any, ...args: any[]) => void | Promise<void>;
-}
-
-export function defineCommand<
-  O extends OptionsRecord | undefined = undefined,
-  A extends ArgumentsArray | undefined = undefined,
->(definition: CommandDefinition<O, A>): CommandDefinition<O, A> {
-  return definition;
-}

package/src/lib/define-option.ts

@@ -1,15 +0,0 @@
-import type { z } from "zod";
-
-export interface OptionDefinition<S extends z.ZodType = z.ZodType> {
-  name: string;
-  schema: S;
-  description: string;
-  aliases?: Array<string>;
-  placeholder?: string;
-}
-
-export function defineOption<S extends z.ZodType>(
-  definition: OptionDefinition<S>,
-): OptionDefinition<S> {
-  return definition;
-}

package/src/lib/format.ts

@@ -1,108 +0,0 @@
-import { styleText } from "node:util";
-import type { z } from "zod";
-import type { ArgumentDefinition } from "./define-argument.ts";
-import type { AnyCommandDefinition } from "./define-command.ts";
-import type { OptionDefinition } from "./define-option.ts";
-import { getDefault, isBoolean, isRequired } from "./zod-utils.ts";
-
-export function formatGlobalHelp(toolName: string, commands: Record<string, AnyCommandDefinition>) {
-  const names = Object.keys(commands);
-
-  const sections: Array<string> = [styleText("bold", "USAGE"), `  ${toolName} <command> [options]`];
-
-  if (names.length > 0) {
-    const longest = Math.max(...names.map((n) => n.length));
-    const commandList = names
-      .map((name) => `  ${name.padEnd(longest)}  ${commands[name]!.description}`)
-      .join("\n");
-    sections.push("", styleText("bold", "COMMANDS"), commandList);
-  }
-
-  return sections.join("\n");
-}
-
-export function formatCommandHelp(
-  toolName: string,
-  commandName: string,
-  command: AnyCommandDefinition,
-) {
-  const sections: Array<string> = [
-    styleText("bold", "USAGE"),
-    formatUsageLine(toolName, commandName, command),
-  ];
-
-  const argList = formatArgList(command.args ?? []);
-  if (argList !== null) {
-    sections.push("", styleText("bold", "ARGUMENTS"), argList);
-  }
-
-  const optionList = formatOptionList(command.options ?? {});
-  if (optionList !== null) {
-    sections.push("", styleText("bold", "OPTIONS"), optionList);
-  }
-
-  return sections.join("\n");
-}
-
-function formatUsageLine(toolName: string, commandName: string, command: AnyCommandDefinition) {
-  const argPlaceholders = (command.args ?? []).map((a) => `<${a.placeholder}>`).join(" ");
-  const parts = [toolName, commandName];
-  if (argPlaceholders !== "") parts.push(argPlaceholders);
-  parts.push("[options]");
-  return `  ${parts.join(" ")}`;
-}
-
-function formatArgList(args: readonly ArgumentDefinition[]) {
-  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: Record<string, OptionDefinition>) {
-  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: string, schema: z.ZodType): string {
-  const defaultValue = getDefault(schema);
-  if (defaultValue !== undefined) return `${description} (default: ${String(defaultValue)})`;
-  return isRequired(schema) ? description : `${description} (optional)`;
-}
-
-function formatDescription(description: string, schema: z.ZodType): string {
-  if (isRequired(schema)) return `${description} (required)`;
-  const defaultValue = getDefault(schema);
-  return defaultValue === undefined
-    ? description
-    : `${description} (default: ${String(defaultValue)})`;
-}
-
-export function formatErrors(errors: Array<string>) {
-  const errorLines = errors.map((e) => `  ${e}`).join("\n");
-  return `${styleText("bold", "ERRORS")}\n${errorLines}`;
-}

package/src/lib/get-storage.ts

@@ -1,11 +0,0 @@
-import { JsonStorage } from "./json-storage.ts";
-import { OnePasswordStorage } from "./one-password-storage.ts";
-import type { Storage } from "./storage.ts";
-
-export function getStorage(): Storage {
-  const storagePath = process.env.LECOFFRE_STORAGE_PATH;
-  if (storagePath !== undefined) {
-    return new JsonStorage(storagePath);
-  }
-  return new OnePasswordStorage();
-}

package/src/lib/json-storage.ts

@@ -1,74 +0,0 @@
-import { readFile, writeFile } from "node:fs/promises";
-import { ProjectNotFoundError, Storage } from "./storage.ts";
-
-type StoreData = Record<string, Record<string, Record<string, string>>>;
-
-export class JsonStorage extends Storage {
-  private readonly filePath: string;
-
-  constructor(filePath: string) {
-    super();
-    this.filePath = filePath;
-  }
-
-  private async read(): Promise<StoreData> {
-    try {
-      const content = await readFile(this.filePath, "utf-8");
-      return JSON.parse(content) as StoreData;
-    } catch (error) {
-      if ((error as NodeJS.ErrnoException).code === "ENOENT") {
-        return {};
-      }
-      throw error;
-    }
-  }
-
-  private async write(data: StoreData): Promise<void> {
-    await writeFile(this.filePath, JSON.stringify(data, null, 2) + "\n");
-  }
-
-  async getProjects(): Promise<Array<string>> {
-    const data = await this.read();
-    return Object.keys(data);
-  }
-
-  async getProject(project: string): Promise<Record<string, Record<string, string>>> {
-    const data = await this.read();
-    const projectData = data[project];
-    if (projectData === undefined) {
-      throw new ProjectNotFoundError(project);
-    }
-    return Object.fromEntries(Object.entries(projectData).map(([env, vars]) => [env, { ...vars }]));
-  }
-
-  async init(): Promise<void> {
-    // No initialization needed for JSON storage
-  }
-
-  async setVariables(project: string, env: string, vars: Record<string, string>): Promise<void> {
-    const data = await this.read();
-    if (data[project] === undefined) {
-      data[project] = {};
-    }
-    data[project][env] = vars;
-    await this.write(data);
-  }
-
-  async deleteEnvironment(project: string, env: string): Promise<void> {
-    const data = await this.read();
-    const projectData = data[project];
-    if (projectData !== undefined) {
-      delete projectData[env];
-      if (Object.keys(projectData).length === 0) {
-        delete data[project];
-      }
-      await this.write(data);
-    }
-  }
-
-  async deleteProject(project: string): Promise<void> {
-    const data = await this.read();
-    delete data[project];
-    await this.write(data);
-  }
-}