@romaintaillandier1978/dotenv-never-lies 0.3.0 → 0.4.0

package/dist/cli/index.js

@@ -1,77 +1,224 @@
 #!/usr/bin/env node
-import { program } from "commander";
+import { program, CommanderError } from "commander";
 import { assertCommand } from "./commands/assert.js";
 import { generateCommand } from "./commands/generate.js";
 import { reverseEnvCommand } from "./commands/reverseEnv.js";
-import { explainCommand } from "./commands/explain.js";
+import { explainCommand, printHuman } from "./commands/explain.js";
+import { exportCommand } from "./commands/export.js";
+import { toFile } from "./utils/toFile.js";
+import { DnlError, ExitCodes, ValidationError } from "../errors.js";
+import { createRequire } from "node:module";
+const require = createRequire(import.meta.url);
+const packageJson = require("../../package.json");
+const exitCodeHelp = {
+    [ExitCodes.success]: "Succès (tout est valide, sortie OK)",
+    [ExitCodes.usageError]: "Erreur d’usage ou erreur système",
+    [ExitCodes.schemaNotFound]: "Schéma DNL introuvable ou non résolu",
+    [ExitCodes.validationError]: "Validation échouée (env invalide)",
+    [ExitCodes.exportError]: "Erreur d’export (format, écriture fichier, secret, etc.)",
+};
+// #region Program
 program
     .name("dnl")
-    .version("0.1.0")
-    .addHelpText("before", `
-CLI pour dotenv-never-lies.
-Valide, charge et génère des variables d’environnement typées à partir d’un schéma TypeScript/Zod.
+    //.version("0.3.0")
+    .version(packageJson.version)
+    // permet de passer des arguments positionnels, avant / après les options
+    .enablePositionalOptions()
+    .exitOverride()
+    .addHelpText("before", `Résumé :
+  CLI pour dotenv-never-lies.
+  Valide les variables d’environnement typées à partir d’un schéma TypeScript/Zod.
       `)
+    .option("--schema <file>", "Fichier de schéma dnl (ex: path/to/my-dnl.ts). Voir la section Schéma d’environnement pour plus de détails.")
+    .addHelpText("after", `\nExit codes :\n${Object.entries(exitCodeHelp)
+    .map(([key, value]) => `  - ${key}: ${value}`)
+    .join("\n")}
+        `)
+    .addHelpText("after", `\nSchéma d’environnement :
+  Le schéma dotenv-never-lies est résolu dans l’ordre suivant :
+  1. Option --schema si fournie
+  2. Clé "dotenv-never-lies.schema" dans package.json
+  3. Fichiers par convention :
+    - env.dnl.ts
+    - env.dnl.js
+    - dnl.config.ts
+    - dnl.config.js
+  Si aucun schéma n’est trouvé, la commande échoue.
+        `)
     .addHelpText("after", `\nExemples :
         
-        # Vérifier l’environnement à l’exécution et arrêter le process si le schéma n’est pas respecté
-        dnl assert 
-        dnl assert --schema env.dnl.ts
-      
-        # Générer un fichier .env documenté à partir du schéma
-        dnl generate 
-        dnl generate --schema env.dnl.ts --out .env
-      
-        # Créer un schéma env.dnl.ts depuis un .env existant
-        dnl reverse-env --source .env
-      
-        # Afficher les variables connues et leur description
-        dnl explain
-      `);
+  # Vérifier l’environnement à l’exécution et arrêter le process si le schéma n’est pas respecté
+  dnl assert 
+  dnl assert --schema my-dnl.ts
+  
+  # Générer un fichier .env documenté à partir du schéma
+  dnl generate 
+  dnl generate --schema my-dnl.ts --out .env
+  
+  # Créer un schéma env.dnl.ts depuis un .env existant
+  dnl reverse-env --source .env
+  
+  # Afficher les variables connues et leur description
+  dnl explain
+
+  # Exporter les variables au format docker-args
+  dnl export docker-args --source .env
+  
+    `);
+// #endregion Program
+// #region assert
 program
     .command("assert")
     .description("Vérifie l’environnement runtime et termine le process si le schéma n’est pas respecté.")
-    .option("--schema <file>", "Fichier de schéma dnl (ex: my-dnl.ts)", "env.dnl.ts")
     .option("-s, --source <source>", "Source des variables (défaut : process.env)")
     .action(assertCommand)
     .addHelpText("after", `\nExemples :
         
-        # Valider les variables d’environnement de process.env
-        # Recommandé en CI pour empêcher un démarrage avec une configuration invalide
-        dnl assert
-        dnl assert --schema my-dnl.ts
-
-        # Valider les variables d’environnement depuis un fichier .env
-        # Recommandé en local (préparation du schéma, onboarding)
-        dnl assert --source .env
-        dnl assert --schema my-dnl.ts --source .env
-
-        # valider les variables d'environnement du fichier fourni par la CI
-        dnl assert --source $ENV_FILE
-        dnl assert --schema my-dnl.ts --source $ENV_FILE
+  # Valider les variables d’environnement de process.env
+  # Recommandé en CI pour empêcher un démarrage avec une configuration invalide
+  dnl assert
+  dnl assert --schema my-dnl.ts
+  
+  # Valider les variables d’environnement depuis un fichier .env
+  # Recommandé en local (préparation du schéma, onboarding)
+  dnl assert --source .env
+  dnl assert --schema my-dnl.ts --source .env
+  
+  # valider les variables d'environnement du fichier fourni par la CI
+  dnl assert --source $ENV_FILE
+  dnl assert --schema my-dnl.ts --source $ENV_FILE
       `);
+// #endregion assert
+// #region export
+const exportHelp = {
+    "docker-args": "Arguments `--env KEY=VALUE` pour `docker run`",
+    "docker-env": "Fichier compatible `--env-file` Docker",
+    "github-env": "Injection dans l’environnement d’un job GitHub Actions",
+    "github-secret": "Secrets GitHub via gh CLI (repo ou organisation)",
+    "gitlab-env": "Variables d’environnement GitLab CI",
+    "k8s-configmap": "ConfigMap Kubernetes (variables NON sensibles)",
+    "k8s-secret": "Secret Kubernetes (variables sensibles uniquement)",
+    env: "Fichier .env nettoyé (sans commentaires inutiles)",
+    json: "Objet JSON clé/valeur",
+    ts: "Objet TypeScript typé",
+    js: "Objet JavaScript",
+};
+program
+    .command("export")
+    .description("Exporte les variables d'environnement dans un format spécifié")
+    .argument("<format>", "Format d'exportation. Voir liste et exemples à la fin")
+    .option("-s, --source <source>", "Source des variables (sans source process.env sera utilisé)")
+    .option("--hide-secret", 'Masquer les variables sensibles (rempalcer par "********")')
+    .option("--exclude-secret", "Exclure les variables sensibles (ne pas les montrer du tout)")
+    .option("--include-comments", "Inclure les commentaires dans l'exportation (ne fonctionne pas avec le format json)")
+    .option("-o, --out <file>", "Fichier de sortie")
+    .option("-f,--force", "Écraser le fichier existant, en conjonction avec l'option -o ou --out")
+    .option("--k8s-name <name>", "Nom du secret k8s default: env-secret pour le format k8s-secret, env-config pour le format k8s-configmap")
+    .option("--github-org <org>", "Nom de l'organisation github")
+    .action(async (opts) => {
+    const { content, warnings, out } = await exportCommand(opts);
+    if (out) {
+        await toFile(content, out, opts.force ?? false);
+    }
+    else {
+        console.log(content);
+    }
+    for (const warning of warnings) {
+        console.error(`${warning}`);
+    }
+})
+    .addHelpText("after", `\nFormats d'exportation :\n${Object.entries(exportHelp)
+    .map(([key, value]) => `  - ${key}: ${value}`)
+    .join("\n")}
+        `)
+    .addHelpText("after", `\nExemples :
+      
+  # --- Cas simples ----------------------------------------------------
+  
+  # Exporter les variables d'environnement au format JSON depuis un fichier .env
+  dnl export json --source .env
+  
+  # Nettoyer un fichier .env (retirer commentaires et lignes inutiles)
+  dnl export env --source .env --out .env.clean
+  dnl export env --source .env -fo .env
+  
+  
+  # --- Docker / CI ----------------------------------------------------
+  
+  # Exporter les variables au format docker-args
+  dnl export docker-args --source .env
+  
+  # Exemple concret en CI pour lancer un conteneur Docker
+  # (les variables sont injectées dynamiquement)
+  docker run \\
+    $(dnl export docker-args --source $DOTENV_FILE) \\
+    --restart always \\
+    -d my-image:latest
+  
+  
+  # --- GitHub Actions -------------------------------------------------
+  
+  # Exporter les variables comme secrets GitHub (repo courant)
+  # Nécessite gh CLI configuré (gh auth login)
+  dnl export github-secret
+  
+  # Exporter les variables comme secrets d'une organisation GitHub
+  dnl export github-secret --github-org my-org
+  
+  # Exemple d'usage dans un job GitHub Actions :
+  # (les variables sont injectées dans l'environnement du job)
+  dnl export github-env >> $GITHUB_ENV
+  
+  
+  # --- Kubernetes -----------------------------------------------------
+  
+  # Générer un ConfigMap Kubernetes (variables NON sensibles)
+  dnl export k8s-configmap --out k8s-configmap.yaml
+  
+  # Générer un Secret Kubernetes à partir d'un fichier .env
+  dnl export k8s-secret --source .env --k8s-name my-secret --out k8s-secret.yaml
+  
+  # Appliquer les fichiers générés
+  kubectl apply -f k8s-configmap.yaml
+  kubectl apply -f k8s-secret.yaml
+  
+  # attention : si aucun secret n'est présent dans la config dnl, pour k8s-secret, la sortie sera vide
+  
+  # --- TypeScript / JavaScript ---------------------------------------
+  
+  # Exporter les variables sous forme d'objet TypeScript typé, ou js
+  dnl export ts --out env.generated.ts
+  dnl export js --out env.generated.js
+  `);
+// #endregion export
+// #region generate
 program
     .command("generate")
     .description("Génère un fichier .env à partir d’un schéma dnl.\n" +
     "Utile pour initialiser un projet ou faciliter l’onboarding d’un nouveau développeur.\n" +
     "Seules les valeurs définies par défaut dans le schéma sont écrites.")
-    .option("--schema <file>", "Fichier de schéma env (ex: env.dnl.ts)")
     .option("-o, --out <file>", "Fichier de sortie (défaut : .env)")
     .option("-f, --force", "Écraser le fichier existant")
-    .action(generateCommand)
+    .action(async (opts) => {
+    const { content, out } = await generateCommand(opts);
+    await toFile(content, out, opts.force ?? false);
+})
     .addHelpText("after", `\nExemples :
         
-        # Générer un fichier .env à partir du schéma par défaut (env.dnl.ts)
-        dnl generate
-
-        # Générer un fichier .env à partir d'un schéma spécifié
-        dnl generate --schema my-dnl.ts
-
-        # Générer un fichier .env.local à partir du schéma
-        dnl generate --out .env.local
-
-        # Générer un fichier .env à partir d'un schéma et écraser le fichier existant
-        dnl generate --out .env --force
+  # Générer un fichier .env à partir du schéma par défaut (env.dnl.ts)
+  dnl generate
+  
+  # Générer un fichier .env à partir d'un schéma spécifié
+  dnl generate --schema my-dnl.ts
+  
+  # Générer un fichier .env.local à partir du schéma
+  dnl generate --out .env.local
+  
+  # Générer un fichier .env à partir d'un schéma et écraser le fichier existant
+  dnl generate --out .env --force
       `);
+// #endregion generate
+// #region reverse-env
 program
     .command("reverse-env")
     .description("Génère un schéma dotenv-never-lies à partir d’un fichier .env.\n" +
@@ -81,47 +228,87 @@ program
     .option("-o, --out <file>", "Fichier dnl de sortie", "env.dnl.ts")
     .option("-f, --force", "Écraser le fichier existant")
     .option("--guess-secret", "Tenter de deviner les variables sensibles (heuristique)")
-    .action(reverseEnvCommand)
+    .action(async (opts) => {
+    const { content, out, warnings } = await reverseEnvCommand(opts);
+    await toFile(content, out, opts.force ?? false);
+    for (const warning of warnings) {
+        console.error(`${warning}`);
+    }
+})
     .addHelpText("after", `\nExemples :
         
-        # Générer un schéma env.dnl.ts à partir d'un fichier .env
-        dnl reverse-env
-
-        # Générer un schéma env.dnl.ts à partir d'un fichier .env.local
-        dnl reverse-env --source .env.local
-        
-        # Générer un schéma my-dnl.ts à partir d'un fichier .env
-        dnl reverse-env --out my-dnl.ts
-
-        # Générer un schéma env.dnl.ts à partir d'un fichier .env et écraser le fichier existant
-        dnl reverse-env --force
-      `);
+  # Générer un schéma env.dnl.ts à partir d'un fichier .env
+  dnl reverse-env
+  
+  # Générer un schéma env.dnl.ts à partir d'un fichier .env.local
+  dnl reverse-env --source .env.local
+  
+  # Générer un schéma my-dnl.ts à partir d'un fichier .env
+  dnl reverse-env --out my-dnl.ts
+  
+  # Générer un schéma env.dnl.ts à partir d'un fichier .env et écraser le fichier existant
+  dnl reverse-env --force
+  `);
+// #endregion reverse-env
+// #region explain
 program
     .command("explain")
     .description("Affiche la liste des variables d’environnement connues et leur description.")
     .argument("[keys...]", "Clés à expliquer (0..N). Sans argument, toutes les clés.")
-    .option("--schema <file>", "Fichier de schéma env (ex: env.dnl.ts)")
     .option("-f, --format <format>", 'Format d\'affichage ("human" | "json")', "human")
     .action(async (keys, opts) => {
-    const result = await explainCommand({ keys: keys ?? [], schema: opts.schema, format: opts.format });
-    process.exit(result);
+    const { format, result } = await explainCommand({ keys: keys ?? [], schema: opts.schema, format: opts.format });
+    if (format === "human") {
+        printHuman(result);
+    }
+    else {
+        console.log(JSON.stringify(result, null, 2));
+    }
 })
     .addHelpText("after", `\nExemples :
         
-        # expliquer toutes les variables connues et leur description
-        dnl explain
-        
-        # expliquer une variable en détail
-        dnl explain NODE_ENV
-
-        # sortie machine
-        dnl explain --format json
-
-        # expliquer toutes les variables connues et leur description à partir d'un schéma
-        dnl explain --schema another-env.ts
-       
-        # expliquer une partie des variables connues et leur description
-        dnl explain NODE_ENV NODE_PORT 
+  # expliquer toutes les variables connues et leur description
+  dnl explain
+  
+  # expliquer une variable en détail
+  dnl explain NODE_ENV
+  
+  # sortie machine
+  dnl explain --format json
+  
+  # expliquer toutes les variables connues et leur description à partir d'un schéma
+  dnl explain --schema my-dnl.ts
+  
+  # expliquer une partie des variables connues et leur description
+  dnl explain NODE_ENV NODE_PORT 
         
       `);
-program.parse(process.argv);
+// #endregion explain
+try {
+    await program.parseAsync(process.argv);
+    process.exit(ExitCodes.success);
+}
+catch (err) {
+    // Commander lève une erreur contrôlée lorsque l'aide ou la version sont affichées
+    if (err instanceof CommanderError) {
+        if (err.code === "commander.helpDisplayed" || err.code === "commander.version") {
+            process.exit(ExitCodes.success);
+        }
+        process.exit(typeof err.exitCode === "number" ? err.exitCode : ExitCodes.usageError);
+    }
+    if (err instanceof ValidationError) {
+        console.error("❌ Invalid environment variables:\n");
+        for (const issue of err.issues ?? []) {
+            console.error(`- ${issue.key}`);
+            console.error(`  → ${issue.message}`);
+        }
+        process.exit(err.exitCode);
+    }
+    if (err instanceof DnlError) {
+        console.error(err.message);
+        process.exit(err.exitCode);
+    }
+    console.error("Erreur inattendue");
+    console.error(err);
+    process.exit(ExitCodes.usageError);
+}

package/dist/cli/utils/exitCodes.d.ts

@@ -0,0 +1,8 @@
+export declare enum ExitCodes {
+    success = 0,
+    usageError = 1,
+    schemaNotFound = 2,
+    validationError = 3,
+    exportError = 4
+}
+//# sourceMappingURL=exitCodes.d.ts.map

package/dist/cli/utils/exitCodes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"exitCodes.d.ts","sourceRoot":"","sources":["../../../src/cli/utils/exitCodes.ts"],"names":[],"mappings":"AAAA,oBAAY,SAAS;IACjB,OAAO,IAAI;IACX,UAAU,IAAI;IACd,cAAc,IAAI;IAClB,eAAe,IAAI;IACnB,WAAW,IAAI;CAClB"}

package/dist/cli/utils/exitCodes.js

@@ -0,0 +1,8 @@
+export var ExitCodes;
+(function (ExitCodes) {
+    ExitCodes[ExitCodes["success"] = 0] = "success";
+    ExitCodes[ExitCodes["usageError"] = 1] = "usageError";
+    ExitCodes[ExitCodes["schemaNotFound"] = 2] = "schemaNotFound";
+    ExitCodes[ExitCodes["validationError"] = 3] = "validationError";
+    ExitCodes[ExitCodes["exportError"] = 4] = "exportError";
+})(ExitCodes || (ExitCodes = {}));

package/dist/cli/utils/load-schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"load-schema.d.ts","sourceRoot":"","sources":["../../../src/cli/utils/load-schema.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAC;AAEpD,eAAO,MAAM,OAAO,GAAU,YAAY,MAAM,KAAG,OAAO,CAAC,mBAAmB,CAAC,GAAG,CAAC,CAsBlF,CAAC"}
+{"version":3,"file":"load-schema.d.ts","sourceRoot":"","sources":["../../../src/cli/utils/load-schema.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAC;AAGpD,eAAO,MAAM,OAAO,GAAU,YAAY,MAAM,KAAG,OAAO,CAAC,mBAAmB,CAAC,GAAG,CAAC,CA0BlF,CAAC"}

package/dist/cli/utils/load-schema.js

@@ -2,21 +2,28 @@ import { build } from "esbuild";
 import path from "node:path";
 import fs from "node:fs/promises";
 import { pathToFileURL } from "node:url";
+import { SchemaNotFoundError } from "../../errors.js";
 export const loadDef = async (schemaPath) => {
     const outDir = path.join(process.cwd(), ".dnl");
     await fs.mkdir(outDir, { recursive: true });
+    // La on écrase toujours le fichier, mais ca pourrait être un problème.
     const outFile = path.join(outDir, "env.dnl.mjs");
-    await build({
-        entryPoints: [schemaPath],
-        outfile: outFile,
-        format: "esm",
-        platform: "node",
-        target: "node18",
-        bundle: false,
-    });
-    const mod = await import(pathToFileURL(outFile).href);
-    if (!mod.default) {
-        throw new Error("Le fichier env.dnl.ts doit exporter un schéma par défaut (export default).");
+    try {
+        await build({
+            entryPoints: [schemaPath],
+            outfile: outFile,
+            format: "esm",
+            platform: "node",
+            target: "node18",
+            bundle: false,
+        });
+        const mod = await import(pathToFileURL(outFile).href);
+        if (!mod.default) {
+            throw new SchemaNotFoundError(`Le fichier ${schemaPath} doit exporter un schéma par défaut (export default).`);
+        }
+        return mod.default;
+    }
+    catch (error) {
+        throw new SchemaNotFoundError(`Impossible de charger le schéma DNL (${schemaPath}): ${error}`);
     }
-    return mod.default;
 };

package/dist/cli/utils/resolve-schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"resolve-schema.d.ts","sourceRoot":"","sources":["../../../src/cli/utils/resolve-schema.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,iBAAiB,GAAI,UAAU,MAAM,KAAG,MA0BpD,CAAC"}
+{"version":3,"file":"resolve-schema.d.ts","sourceRoot":"","sources":["../../../src/cli/utils/resolve-schema.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,iBAAiB,GAAI,UAAU,MAAM,KAAG,MA6BpD,CAAC"}

package/dist/cli/utils/resolve-schema.js

@@ -1,10 +1,15 @@
 import fs from "node:fs";
 import path from "node:path";
+import { SchemaNotFoundError } from "../../errors.js";
 const CANDIDATES = ["env.dnl.ts", "env.dnl.js", "dnl.config.ts", "dnl.config.js"];
 export const resolveSchemaPath = (cliPath) => {
     // 1. --schema
     if (cliPath) {
-        return path.resolve(process.cwd(), cliPath);
+        const full = path.resolve(process.cwd(), cliPath);
+        if (!fs.existsSync(full)) {
+            throw new SchemaNotFoundError(`Schema file not found: ${cliPath}`);
+        }
+        return full;
     }
     // 2. package.json
     const pkgPath = path.resolve(process.cwd(), "package.json");
@@ -18,10 +23,9 @@ export const resolveSchemaPath = (cliPath) => {
     // 3. convention
     for (const file of CANDIDATES) {
         const full = path.resolve(process.cwd(), file);
-        console.log("full", full);
         if (fs.existsSync(full)) {
             return full;
         }
     }
-    throw new Error("No env schema found. Use --schema or define one in package.json.");
+    throw new SchemaNotFoundError("No env schema found. Use --schema, define dotenv-never-lies.schema in package.json, or add env.dnl.ts");
 };

package/dist/cli/utils/toFile.d.ts

@@ -0,0 +1,2 @@
+export declare const toFile: (content: string, path: string, force?: boolean) => Promise<void>;
+//# sourceMappingURL=toFile.d.ts.map

package/dist/cli/utils/toFile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toFile.d.ts","sourceRoot":"","sources":["../../../src/cli/utils/toFile.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,MAAM,GAAU,SAAS,MAAM,EAAE,MAAM,MAAM,EAAE,QAAO,OAAe,KAAG,OAAO,CAAC,IAAI,CAKhG,CAAC"}

package/dist/cli/utils/toFile.js

@@ -0,0 +1,8 @@
+import { ExportError } from "../../errors.js";
+import fs from "node:fs";
+export const toFile = async (content, path, force = false) => {
+    if (fs.existsSync(path) && !force) {
+        throw new ExportError(`${path} already exists. Use --force to overwrite.`);
+    }
+    fs.writeFileSync(path, content);
+};

package/dist/core.js

@@ -1,7 +1,7 @@
 import { z } from "zod";
 import dotenv from "dotenv";
 import dotenvExpand from "dotenv-expand";
-import { EnvFileNotFoundError } from "./errors.js";
+import { DnlError, ExitCodes } from "./errors.js";
 import fs from "fs";
 /**
  * Définit un schéma d'environnement.
@@ -41,7 +41,7 @@ export const define = (def) => {
  */
 export const readEnvFile = (path) => {
     if (!fs.existsSync(path)) {
-        throw new EnvFileNotFoundError(path);
+        throw new DnlError(`Env file not found: ${path}`, ExitCodes.usageError);
     }
     const content = fs.readFileSync(path);
     const parsed = dotenv.parse(content);

package/dist/errors.d.ts

@@ -1,4 +1,31 @@
-export declare class EnvFileNotFoundError extends Error {
-    constructor(path: string);
+export declare enum ExitCodes {
+    success = 0,
+    usageError = 1,
+    schemaNotFound = 2,
+    validationError = 3,
+    exportError = 4
+}
+export declare class DnlError extends Error {
+    readonly exitCode: ExitCodes;
+    constructor(message: string, exitCode: ExitCodes);
+}
+export declare class UsageError extends DnlError {
+    constructor(message: string);
+}
+export declare class SchemaNotFoundError extends DnlError {
+    constructor(message: string);
+}
+export declare class ValidationError extends DnlError {
+    readonly issues?: {
+        key: string;
+        message: string;
+    }[] | undefined;
+    constructor(message: string, issues?: {
+        key: string;
+        message: string;
+    }[] | undefined);
+}
+export declare class ExportError extends DnlError {
+    constructor(message: string);
 }
 //# sourceMappingURL=errors.d.ts.map

package/dist/errors.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA,qBAAa,oBAAqB,SAAQ,KAAK;gBAC/B,IAAI,EAAE,MAAM;CAI3B"}
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA,oBAAY,SAAS;IACjB,OAAO,IAAI;IACX,UAAU,IAAI;IACd,cAAc,IAAI;IAClB,eAAe,IAAI;IACnB,WAAW,IAAI;CAClB;AAED,qBAAa,QAAS,SAAQ,KAAK;aAGX,QAAQ,EAAE,SAAS;gBADnC,OAAO,EAAE,MAAM,EACC,QAAQ,EAAE,SAAS;CAI1C;AACD,qBAAa,UAAW,SAAQ,QAAQ;gBACxB,OAAO,EAAE,MAAM;CAG9B;AACD,qBAAa,mBAAoB,SAAQ,QAAQ;gBACjC,OAAO,EAAE,MAAM;CAG9B;AAED,qBAAa,eAAgB,SAAQ,QAAQ;aAGrB,MAAM,CAAC,EAAE;QACrB,GAAG,EAAE,MAAM,CAAC;QACZ,OAAO,EAAE,MAAM,CAAC;KACnB,EAAE;gBAJH,OAAO,EAAE,MAAM,EACC,MAAM,CAAC,EAAE;QACrB,GAAG,EAAE,MAAM,CAAC;QACZ,OAAO,EAAE,MAAM,CAAC;KACnB,EAAE,YAAA;CAIV;AAED,qBAAa,WAAY,SAAQ,QAAQ;gBACzB,OAAO,EAAE,MAAM;CAG9B"}

package/dist/errors.js

@@ -1,6 +1,35 @@
-export class EnvFileNotFoundError extends Error {
-    constructor(path) {
-        super(`Env file not found: ${path}`);
-        this.name = "EnvFileNotFoundError";
+export var ExitCodes;
+(function (ExitCodes) {
+    ExitCodes[ExitCodes["success"] = 0] = "success";
+    ExitCodes[ExitCodes["usageError"] = 1] = "usageError";
+    ExitCodes[ExitCodes["schemaNotFound"] = 2] = "schemaNotFound";
+    ExitCodes[ExitCodes["validationError"] = 3] = "validationError";
+    ExitCodes[ExitCodes["exportError"] = 4] = "exportError";
+})(ExitCodes || (ExitCodes = {}));
+export class DnlError extends Error {
+    constructor(message, exitCode) {
+        super(message);
+        this.exitCode = exitCode;
+    }
+}
+export class UsageError extends DnlError {
+    constructor(message) {
+        super(message, ExitCodes.usageError);
+    }
+}
+export class SchemaNotFoundError extends DnlError {
+    constructor(message) {
+        super(message, ExitCodes.schemaNotFound);
+    }
+}
+export class ValidationError extends DnlError {
+    constructor(message, issues) {
+        super(message, ExitCodes.validationError);
+        this.issues = issues;
+    }
+}
+export class ExportError extends DnlError {
+    constructor(message) {
+        super(message, ExitCodes.exportError);
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@romaintaillandier1978/dotenv-never-lies",
-    "version": "0.3.0",
+    "version": "0.4.0",
     "description": "Typed, validated, and explicit environment variables — powered by Zod.",
     "license": "MIT",
     "author": "Romain TAILLANDIER",
@@ -9,6 +9,14 @@
         "type": "git",
         "url": "https://github.com/romaintaillandier1978/dotenv-never-lies"
     },
+    "scripts": {
+        "build": "tsc",
+        "pack": "rm -rf dist && yarn build && npm pack --pack-destination ./dist",
+        "pack:check": "npm pack --dry-run",
+        "release:patch": "npm version patch",
+        "release:minor": "npm version minor",
+        "release:major": "npm version major"
+    },
     "keywords": [
         "env",
         "environment",
@@ -42,14 +50,6 @@
     "bin": {
         "dnl": "./dist/cli/index.js"
     },
-    "scripts": {
-        "build": "tsc",
-        "prepublishOnly": "npm test && npm run build",
-        "test": "yarn build &&  node dist/DnlTest.js",
-        "dev": "tsx src/cli/index.ts",
-        "devold": "yarn build && node dist/cli/index.js",
-        "gen": "rm -rf dist; rm dotenv-never-lies-v*.tgz; yarn build && yarn pack"
-    },
     "peerDependencies": {
         "zod": ">=4.2.1"
     },