dotenv-gad 1.0.2 → 1.2.0

package/README.md

@@ -100,7 +100,7 @@ npx dotenv-gad types
 - Interactive fixes
 - Strict mode
 - Custom schema paths
-- CI/CD friendly (comming soon!)
+- CI/CD friendly
 
 ### Secret Management
 
@@ -202,4 +202,4 @@ Environment validation failed:
 
 MIT © [Kasim Lyee]
 
-[![contribution](https://github.com/kasimlyee/dotenv-gad/blob/main/CONTRIBUTING.md)] are welcome!!
+[Contributions](https://github.com/kasimlyee/dotenv-gad/blob/main/CONTRIBUTING.md) are welcome!!

package/dist/cli/commands/check.js

@@ -0,0 +1,41 @@
+import { Command } from "commander";
+import chalk from "chalk";
+import ora from "ora";
+import { validateEnv } from "../../index.js";
+import { AggregateError } from "../../errors.js";
+import { loadSchema } from "./utils.js";
+export default function (program) {
+    return new Command("check")
+        .description("Validate .env against schema")
+        .option("--strict", "Fail on extra env vars not in schema")
+        .option("--fix", "Attempt to fix errors interactively")
+        .action(async (option, command) => {
+        const rootOpts = command.parent.opts();
+        const spinner = ora("Validating environment...").start();
+        try {
+            const schema = await loadSchema(rootOpts.schema);
+            const env = validateEnv(schema, {
+                strict: option.strict,
+            });
+            spinner.succeed(chalk.green("Environment validation passed!"));
+            console.log(chalk.dim(`Found ${Object.keys(env).length} valid variables`));
+        }
+        catch (error) {
+            spinner.stop();
+            if (error instanceof AggregateError) {
+                console.error(chalk.red("\nEnvironment validation failed:"));
+                error.errors.forEach((e) => {
+                    console.log(`  ${chalk.yellow(e.key)}: ${e.message}`);
+                    if (e.rule?.docs) {
+                        console.log(chalk.dim(`  ${e.rule.docs}`));
+                    }
+                });
+                process.exit(1);
+            }
+            else {
+                console.error(chalk.red("Unexpected error:"), error);
+                process.exit(2);
+            }
+        }
+    });
+}

package/dist/cli/commands/docs.js

@@ -0,0 +1,22 @@
+import { Command } from "commander";
+import { loadSchema } from "./utils.js";
+import { writeFileSync } from "fs";
+export default function (program) {
+    return new Command("docs")
+        .description("Generate Markdown documentation")
+        .action(async (program, command) => {
+        const schema = await loadSchema(command.parent.opts().schema);
+        let md = `# Environment Variables\n\n`;
+        Object.entries(schema).forEach(([key, rule]) => {
+            md += `## \'${key}\'\n\n`;
+            md += `- **Type**: ${rule.type}\n`;
+            if (rule.docs)
+                md += `- **Description**: ${rule.docs}\n`;
+            if (rule.default) {
+                md += `- **Default**: \'${rule.default}\'}\n`;
+            }
+            md += "\n";
+        });
+        writeFileSync("ENV.md", md);
+    });
+}

package/dist/cli/commands/fix.js

@@ -0,0 +1,57 @@
+import { Command } from "commander";
+import chalk from "chalk";
+import inquirer from "inquirer";
+import { loadSchema, applyFix } from "./utils.js";
+import { validateEnv } from "../../index.js";
+import { AggregateError } from "../../errors.js";
+import dotenv from "dotenv";
+export default function (program) {
+    return new Command("fix")
+        .description("Interactively fix environment issues")
+        .action(async (options, command) => {
+        const rootOpts = command.parent.opts();
+        const schema = await loadSchema(rootOpts.schema);
+        try {
+            // Load the current .env file
+            const envPath = rootOpts.env || ".env";
+            dotenv.config({ path: envPath });
+            // Try to validate - if it succeeds, there are no issues
+            validateEnv(schema);
+            console.log(chalk.green("✓ No issues found! Environment is valid."));
+            return;
+        }
+        catch (error) {
+            if (error instanceof AggregateError) {
+                console.log(chalk.yellow(`\nFound ${error.errors.length} issue(s):\n`));
+                error.errors.forEach((e) => {
+                    console.log(`  ${chalk.red("✗")} ${chalk.yellow(e.key)}: ${e.message}`);
+                    if (e.rule?.docs) {
+                        console.log(chalk.dim(`    ${e.rule.docs}`));
+                    }
+                });
+                const { confirmed } = await inquirer.prompt({
+                    type: "confirm",
+                    name: "confirmed",
+                    message: `\nWould you like to fix these issues interactively?`,
+                    default: true,
+                });
+                if (confirmed) {
+                    // Convert errors array to issues object format expected by applyFix
+                    const issues = {};
+                    error.errors.forEach((e) => {
+                        issues[e.key] = { value: e.value, key: e.key };
+                    });
+                    await applyFix(issues, schema, rootOpts.env || ".env");
+                }
+                else {
+                    console.log(chalk.dim("\nFix cancelled."));
+                    process.exit(1);
+                }
+            }
+            else {
+                console.error(chalk.red("Unexpected error:"), error);
+                process.exit(2);
+            }
+        }
+    });
+}

package/dist/cli/commands/init.js

@@ -0,0 +1,61 @@
+import { Command } from "commander";
+import chalk from "chalk";
+import ora from "ora";
+import { writeFileSync, existsSync } from "fs";
+import inquirer from "inquirer";
+import { dirname } from "path";
+import { fileURLToPath } from "url";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+export default function (program) {
+    return new Command("init")
+        .description("Initialize new schema file")
+        .option("--force", "Overwrite existing files")
+        .action(async (options, command) => {
+        const rootOpts = command.parent.opts();
+        const schemaPath = rootOpts.schema;
+        if (existsSync(schemaPath)) {
+            if (!options.force) {
+                const { overwrite } = await inquirer.prompt({
+                    type: "confirm",
+                    name: "overwrite",
+                    message: "Schema file already exists. Overwrite?",
+                    default: false,
+                });
+                if (!overwrite)
+                    process.exit(0);
+            }
+        }
+        const spinner = ora("Creating new schema...").start();
+        try {
+            const template = `import { defineSchema } from 'dotenv-gad';
+
+export default defineSchema({
+  // Add your environment variables here
+  PORT: {
+    type: 'number',
+    default: 3000,
+    docs: 'Port to run the server on'
+  },
+  NODE_ENV: {
+    type: 'string',
+    enum: ['development', 'production', 'test'],
+    default: 'development'
+  },
+  DB_URL: {
+    type: 'string',
+    required: true,
+    docs: 'Database connection URL'
+  }
+});
+`;
+            writeFileSync(schemaPath, template);
+            spinner.succeed(chalk.green(`Created ${schemaPath} successfully!`));
+            console.log(chalk.dim("\nEdit this file to define your environment schema"));
+        }
+        catch (error) {
+            spinner.fail(chalk.red("Failed to create schema file"));
+            console.error(error);
+            process.exit(1);
+        }
+    });
+}

package/dist/cli/commands/sync.js

@@ -0,0 +1,37 @@
+import { Command } from "commander";
+import chalk from "chalk";
+import ora from "ora";
+import { writeFileSync } from "fs";
+import { loadSchema } from "./utils.js";
+export default function (program) {
+    return new Command("sync")
+        .description("Genearte/update .env.example file")
+        .option("--output <file>", "Output file path", ".env.example")
+        .action(async (options, command) => {
+        const rootOpts = command.parent.opts();
+        const spinner = ora("Generating .env.example.......").start();
+        try {
+            const schema = await loadSchema(rootOpts.schema);
+            let exampleContent = "# Auto-generated by dotenv-gad\n\n";
+            Object.entries(schema).forEach(([key, rule]) => {
+                if (rule.sensitive)
+                    return;
+                exampleContent += `# ${rule.docs || "No description available"}\n`;
+                exampleContent += `# Type: ${rule.type}\n`;
+                if (rule.default !== undefined) {
+                    exampleContent += `# Default: ${JSON.stringify(rule.default)}\n`;
+                }
+                exampleContent += `${key}=${rule.default
+                    ? JSON.stringify(rule.default)
+                    : ""}\n\n`;
+            });
+            writeFileSync(options.output, exampleContent.trim());
+            spinner.succeed(chalk.green(`Generated ${options.output} successfully!`));
+        }
+        catch (error) {
+            spinner.fail(chalk.red(`Failed to generate .env.example`));
+            console.error(error);
+            process.exit(1);
+        }
+    });
+}

package/dist/cli/commands/types.js

@@ -0,0 +1,87 @@
+import { Command } from "commander";
+import chalk from "chalk";
+import ora from "ora";
+import { writeFileSync } from "fs";
+import { loadSchema } from "./utils.js";
+function getTypeForRule(rule) {
+    switch (rule.type) {
+        case "number":
+        case "port":
+            return "number";
+        case "boolean":
+            return "boolean";
+        case "date":
+            return "Date";
+        case "array":
+            return rule.items ? `${getTypeForRule(rule.items)}[]` : "any[]";
+        case "object":
+        case "json":
+            return "Record<string, any>";
+        case "string":
+        case "email":
+        case "url":
+        case "ip":
+        default:
+            return "string";
+    }
+}
+export default function (program) {
+    return new Command("types")
+        .description("Generate Typescript types")
+        .option("--output <file>", "Output file path", "env.d.ts")
+        .action(async (options, command) => {
+        const rootOpts = command.parent.opts();
+        const spinner = ora("Generating type definitions.......").start();
+        try {
+            const schema = await loadSchema(rootOpts.schema);
+            let typeContent = "// Auto-generated by dotenv-gad\n\ndeclare namespace NodeJS{\n  interface ProcessEnv{\n";
+            Object.entries(schema).forEach(([key, rule]) => {
+                const schemaRule = rule;
+                let type;
+                switch (schemaRule.type) {
+                    case "number":
+                    case "port":
+                        type = "number";
+                        break;
+                    case "boolean":
+                        type = "boolean";
+                        break;
+                    case "date":
+                        type = "Date";
+                        break;
+                    case "array":
+                        if (schemaRule.items) {
+                            const itemType = getTypeForRule(schemaRule.items);
+                            type = `${itemType}[]`;
+                        }
+                        else {
+                            type = "any[]";
+                        }
+                        break;
+                    case "object":
+                    case "json":
+                        type = "Record<string, any>";
+                        break;
+                    case "string":
+                    case "email":
+                    case "url":
+                    case "ip":
+                    default:
+                        type = "string";
+                }
+                if (schemaRule.enum) {
+                    type = schemaRule.enum.map((v) => JSON.stringify(v)).join(" | ");
+                }
+                typeContent += `    ${key}${schemaRule.required ? "" : "?"}: ${type};\n`;
+            });
+            typeContent += "  }\n}\n";
+            writeFileSync(options.output, typeContent);
+            spinner.succeed(chalk.green(`Generated ${options.output} successfully!`));
+        }
+        catch (error) {
+            spinner.fail(chalk.red("Failed to generate type definitions"));
+            console.error(error);
+            process.exit(1);
+        }
+    });
+}

package/dist/cli/commands/utils.js

@@ -0,0 +1,91 @@
+import { readFileSync, writeFileSync, unlinkSync } from "fs";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+import { transformSync } from "esbuild";
+import Chalk from "chalk";
+import inquirer from "inquirer";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+/**
+ * Loads a schema from a file.
+ * @param schemaPath Path to the schema file.
+ * @returns The loaded schema.
+ * @throws If the schema file is malformed or cannot be loaded.
+ */
+export async function loadSchema(schemaPath) {
+    const loadTsModule = async (tsFilePath) => {
+        const tempFile = join(__dirname, "../../temp-schema.mjs");
+        try {
+            const tsCode = readFileSync(tsFilePath, "utf-8");
+            const { code } = transformSync(tsCode, {
+                format: "esm",
+                loader: "ts",
+                target: "esnext",
+            });
+            writeFileSync(tempFile, code);
+            return (await import(`${tempFile}?t=${Date.now()}`)).default;
+        }
+        finally {
+            unlinkSync(tempFile);
+        }
+    };
+    try {
+        if (schemaPath.endsWith(".ts")) {
+            return await loadTsModule(schemaPath);
+        }
+        else if (schemaPath.endsWith(".js")) {
+            return (await import(`${schemaPath}?t=${Date.now()}`)).default;
+        }
+        else if (schemaPath.endsWith(".json")) {
+            return JSON.parse(readFileSync(schemaPath, "utf-8"));
+        }
+        throw new Error(`Unsupported schema format. Use .ts, .js or .json`);
+    }
+    catch (error) {
+        throw new Error(`Failed to load schema from ${schemaPath}: ${error.message}`);
+    }
+}
+/**
+ * Applies fixes to the given environment file by prompting the user to input
+ * values for missing variables and variables that do not match the schema.
+ *
+ * @param issues An object where each key is the name of an environment variable
+ * and the value is an object containing the `value` property (which is the
+ * invalid value) and the `key` property (which is the name of the variable).
+ * @param schema The schema definition for the environment variables.
+ * @param envPath The path to the environment file. Defaults to `.env`.
+ * @throws If the schema is malformed or if the user cancels the prompt.
+ */
+export async function applyFix(issues, schema, envPath = ".env") {
+    const envLines = readFileSync(envPath, "utf-8").split("\n");
+    for (const key in issues) {
+        if (!Object.prototype.hasOwnProperty.call(issues, key))
+            continue;
+        const issue = issues[key];
+        const rule = schema[key];
+        if (!rule) {
+            console.error(Chalk.red(`Error: Could not find rule for key ${key} in schema`));
+            continue;
+        }
+        const { value } = await inquirer.prompt({
+            type: "input",
+            name: "value",
+            message: `${Chalk.yellow(key)} (${rule.docs || "No description"})`,
+            default: rule.default !== undefined ? String(rule.default) : "",
+            validate: (input) => {
+                if (rule.required && !input) {
+                    return "Value is required";
+                }
+                return true;
+            },
+        });
+        const lineIndex = envLines.findIndex((line) => line.startsWith(`${key}=`));
+        if (lineIndex >= 0) {
+            envLines[lineIndex] = `${key}=${value}`;
+        }
+        else {
+            envLines.push(`${key}=${value}`);
+        }
+    }
+    writeFileSync(envPath, envLines.join("\n"));
+    console.log(Chalk.green(`Updated ${envPath} successfully!`));
+}

package/dist/compose.js

@@ -0,0 +1,23 @@
+/**
+ * Compose multiple schema definitions into a single one.
+ *
+ * @example
+ * const dbSchema = {
+ *   DB_HOST: { type: "string" },
+ *   DB_USER: { type: "string" },
+ *   DB_PASSWORD: { type: "string", sensitive: true },
+ * };
+ *
+ * const appSchema = {
+ *   APP_NAME: { type: "string" },
+ *   APP_PORT: { type: "number" },
+ * };
+ *
+ * const fullSchema = composeSchema(dbSchema, appSchema);
+ *
+ * @param {...SchemaDefinition[]} schemas - schema definitions to compose
+ * @returns {SchemaDefinition} - a single schema definition with all the properties
+ */
+export function composeSchema(...schemas) {
+    return Object.assign({}, ...schemas);
+}

package/dist/errors.js

@@ -0,0 +1,34 @@
+export class EnvValidationError extends Error {
+    key;
+    message;
+    receiveValue;
+    constructor(key, message, receiveValue) {
+        super(message);
+        this.key = key;
+        this.message = message;
+        this.receiveValue = receiveValue;
+        this.name = "EnvValidationError";
+    }
+}
+export class AggregateError extends Error {
+    errors;
+    constructor(errors, message) {
+        super(message);
+        this.errors = errors;
+        this.name = "AggregateError";
+        Object.setPrototypeOf(this, AggregateError.prototype);
+    }
+    toString() {
+        const errorList = this.errors
+            .map((e) => {
+            let msg = `  - ${e.key}: ${e.message}`;
+            if (e.value !== undefined)
+                msg += ` (received: ${JSON.stringify(e.value)})`;
+            if (e.rule?.docs)
+                msg += `\n    ${e.rule.docs}`;
+            return msg;
+        })
+            .join("\n");
+        return `${this.message}:\n${errorList}`;
+    }
+}

package/dist/schema.js

@@ -0,0 +1,10 @@
+/**
+ * Define a schema for a set of environment variables.
+ *
+ * @param schema A record where each key is the name of an environment variable
+ * and the value is a `SchemaRule` object that defines the rules for that
+ * variable.
+ */
+export function defineSchema(schema) {
+    return schema;
+}

package/dist/types/validator.d.ts

@@ -3,6 +3,12 @@ export declare class EnvValidator {
     private schema;
     private options?;
     private errors;
+    /**
+     * Constructs a new EnvValidator instance.
+     * @param {SchemaDefinition} schema The schema definition for the environment variables.
+     * @param {Object} [options] Optional options for the validation process.
+     * @param {boolean} [options.strict] When true, environment variables not present in the schema will be rejected.
+     */
     constructor(schema: SchemaDefinition, options?: {
         strict?: boolean;
     } | undefined);

package/dist/utils.js

@@ -0,0 +1,36 @@
+import dotenv from "dotenv";
+import { EnvValidator } from "./validator.js";
+/**
+ * Load the environment variables from a .env file, validate them against the schema
+ * and return an object with the validated values.
+ *
+ * @param schema The schema definition for the environment variables.
+ * @param options Options for the validation process.
+ *
+ * @returns A validated object with the environment variables.
+ */
+export function loadEnv(schema, options) {
+    const env = dotenv.config().parsed || {};
+    const validator = new EnvValidator(schema, options);
+    return validator.validate(env);
+}
+/**
+ * Create a proxy around the validated environment variables. The proxy will
+ * throw an error if you try to access a variable that is not validated.
+ *
+ * @param validatedEnv The validated environment variables.
+ *
+ * @returns A proxy object that throws an error if you access an
+ * unvalidated variable.
+ */
+export function createEnvProxy(validatedEnv) {
+    return new Proxy(validatedEnv, {
+        get(target, prop) {
+            const value = target[prop];
+            if (value === undefined) {
+                throw new Error(`Environment variable ${String(prop)} is not validated`);
+            }
+            return value;
+        },
+    });
+}

package/dist/validator.js

@@ -0,0 +1,194 @@
+import { AggregateError } from "./errors.js";
+export class EnvValidator {
+    schema;
+    options;
+    errors = [];
+    /**
+     * Constructs a new EnvValidator instance.
+     * @param {SchemaDefinition} schema The schema definition for the environment variables.
+     * @param {Object} [options] Optional options for the validation process.
+     * @param {boolean} [options.strict] When true, environment variables not present in the schema will be rejected.
+     */
+    constructor(schema, options) {
+        this.schema = schema;
+        this.options = options;
+    }
+    validate(env) {
+        this.errors = [];
+        const result = {};
+        for (const [key, rule] of Object.entries(this.schema)) {
+            try {
+                result[key] = this.validateKey(key, rule, env[key]);
+            }
+            catch (error) {
+                if (error instanceof Error) {
+                    this.errors.push({
+                        key,
+                        message: error.message,
+                        value: env[key],
+                        rule,
+                    });
+                }
+            }
+        }
+        if (this.errors.length > 0) {
+            const keys = this.errors.map((e) => e.key).join(", ");
+            throw new AggregateError(this.errors, `Environment validation failed: ${keys}`);
+        }
+        if (this.options?.strict) {
+            const extraVars = Object.keys(env).filter((k) => !(k in this.schema));
+            if (extraVars.length > 0) {
+                throw new Error(`Unexpected environment variables: ${extraVars.join(", ")}`);
+            }
+        }
+        return result;
+    }
+    validateKey(key, rule, value) {
+        const effectiveRule = this.getEffectiveRule(key, rule);
+        if (value === undefined || value === "") {
+            if (effectiveRule.required)
+                throw new Error(`Missing required environment variable`);
+            return effectiveRule.default;
+        }
+        if (effectiveRule.transform) {
+            value = effectiveRule.transform(value);
+        }
+        switch (effectiveRule.type) {
+            case "string":
+                value = String(value).trim();
+                if (effectiveRule.minLength && value.length < effectiveRule.minLength) {
+                    throw new Error(`Environment variable ${key} must be at least ${effectiveRule.minLength} characters`);
+                }
+                if (effectiveRule.maxLength && value.length > effectiveRule.maxLength) {
+                    throw new Error(`Environment variable ${key} must be at most ${effectiveRule.maxLength} characters`);
+                }
+                break;
+            case "number":
+                value = Number(value);
+                if (isNaN(value)) {
+                    throw new Error(`Environment variable ${key} must be a number`);
+                }
+                if (effectiveRule.min !== undefined && value < effectiveRule.min) {
+                    throw new Error(`Environment variable ${key} must be at least ${effectiveRule.min}`);
+                }
+                if (effectiveRule.max !== undefined && value > effectiveRule.max) {
+                    throw new Error(`Environment variable ${key} must be at most ${effectiveRule.max}`);
+                }
+                break;
+            case "boolean":
+                if (typeof value === "string") {
+                    value = value.toLowerCase();
+                    if (value === "true") {
+                        value = true;
+                    }
+                    else if (value === "false") {
+                        value = false;
+                    }
+                }
+                if (typeof value !== "boolean") {
+                    throw new Error(`Environment variable ${key} must be a boolean (true/false)`);
+                }
+                value = Boolean(value);
+                break;
+            case "date":
+                const date = new Date(value);
+                if (isNaN(date.getTime())) {
+                    throw new Error(`Environment variable ${key} must be a valid date`);
+                }
+                value = date;
+                break;
+            case "url":
+                try {
+                    new URL(String(value));
+                }
+                catch {
+                    throw new Error("Must be a valid URL");
+                }
+                break;
+            case "email":
+                if (!/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(String(value))) {
+                    throw new Error("Must be a valid email");
+                }
+                break;
+            case "ip":
+                if (!/^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/.test(String(value))) {
+                    throw new Error("Must be a valid IP address");
+                }
+                break;
+            case "port":
+                const port = Number(value);
+                if (isNaN(port))
+                    throw new Error("Must be a number");
+                if (port < 1 || port > 65535) {
+                    throw new Error("Must be between 1 and 65535");
+                }
+                break;
+            case "json":
+                try {
+                    value = JSON.parse(value);
+                }
+                catch {
+                    throw new Error("Must be valid JSON");
+                }
+                break;
+            case "array":
+                if (!Array.isArray(value)) {
+                    try {
+                        value = JSON.parse(value);
+                    }
+                    catch {
+                        throw new Error("Must be a valid array or JSON array string");
+                    }
+                }
+                if (effectiveRule.items) {
+                    value = value.map((item, i) => {
+                        try {
+                            return this.validateKey(`${key}[${i}]`, effectiveRule.items, item);
+                        }
+                        catch (error) {
+                            throw new Error(`Array item '${i}':${error.message}`);
+                        }
+                    });
+                }
+                break;
+            case "object":
+                if (typeof value === "string") {
+                    try {
+                        value = JSON.parse(value);
+                    }
+                    catch {
+                        throw new Error("Must be a valid object or JSON string");
+                    }
+                }
+                if (effectiveRule.properties) {
+                    const obj = {};
+                    for (const [prop, propRule] of Object.entries(effectiveRule.properties)) {
+                        try {
+                            obj[prop] = this.validateKey(`${key}.${prop}`, propRule, value[prop]);
+                        }
+                        catch (error) {
+                            throw new Error(`Property '${prop}':${error.message}`);
+                        }
+                    }
+                    value = obj;
+                }
+                break;
+        }
+        if (effectiveRule.enum && !effectiveRule.enum.includes(value)) {
+            throw new Error(`Environment variable ${key} must be one of ${effectiveRule.enum.join(", ")}`);
+        }
+        if (effectiveRule.regex && !effectiveRule.regex.test(String(value))) {
+            throw new Error(effectiveRule.regexError ||
+                `Environment variable ${key} must match ${effectiveRule.regex}`);
+        }
+        if (effectiveRule.validate && !effectiveRule.validate(value)) {
+            throw new Error(effectiveRule.error || "Custom validation failed");
+        }
+        return value;
+    }
+    getEffectiveRule(key, rule) {
+        const envName = process.env.NODE_ENV || "development";
+        const envRule = rule.env?.[envName] || {};
+        return { ...rule, ...envRule };
+    }
+}

package/package.json

@@ -1,17 +1,24 @@
 {
   "name": "dotenv-gad",
-  "version": "1.0.2",
+  "version": "1.2.0",
   "main": "dist/index.js",
-  "types": "dist/index.d.ts",
+  "types": "dist/types/index.d.ts",
   "type": "module",
   "bin": {
     "dotenv-guard": "./dist/cli/index.js"
   },
   "scripts": {
-    "build": "tsc && chmod +x ./dist/cli/index.js",
-    "test": "NODE_OPTIONS=--experimental-vm-modules jest",
+    "build": "tsc",
+    "test": "cross-env NODE_OPTIONS=--experimental-vm-modules jest",
+    "test:watch": "cross-env NODE_OPTIONS=--experimental-vm-modules jest --watch",
+    "test:coverage": "cross-env NODE_OPTIONS=--experimental-vm-modules jest --coverage",
     "dev": "tsc --watch",
-    "prepublishOnly": "npm run build && npm test"
+    "lint": "eslint src --ext .ts",
+    "lint:fix": "eslint src --ext .ts --fix",
+    "format": "prettier --write \"src/**/*.ts\" \"__tests__/**/*.ts\"",
+    "format:check": "prettier --check \"src/**/*.ts\" \"__tests__/**/*.ts\"",
+    "prepublishOnly": "npm run build && npm test",
+    "prepare": "husky"
   },
   "keywords": [
     "dotenv",
@@ -19,16 +26,25 @@
     "validation",
     "typescript",
     "schema",
-    "configuration"
+    "configuration",
+    "env",
+    "config",
+    "type-safe",
+    "nodejs",
+    "cli"
   ],
+  "engines": {
+    "node": ">=18.0.0"
+  },
   "exports": {
     ".": {
       "import": "./dist/index.js",
-      "types": "./dist/index.d.ts"
+      "types": "./dist/types/index.d.ts"
     },
     "./package.json": "./package.json"
   },
   "files": [
+    "dist/**/*.js",
     "dist/**/*.d.ts",
     "README.md",
     "LICENSE"
@@ -45,19 +61,34 @@
   },
   "homepage": "https://github.com/kasimlyee/dotenv-gad#readme",
   "devDependencies": {
+    "@eslint/js": "^9.17.0",
     "@types/chalk": "^0.4.31",
     "@types/commander": "^2.12.0",
     "@types/dotenv": "^6.1.1",
+    "@types/eslint__js": "^8.42.3",
     "@types/figlet": "^1.7.0",
     "@types/inquirer": "^9.0.8",
     "@types/jest": "^30.0.0",
     "@types/node": "^24.0.3",
     "@types/ora": "^3.1.0",
+    "cross-env": "^7.0.3",
+    "cross-env-shell": "^7.0.3",
+    "esbuild": "^0.25.5",
+    "eslint": "^9.17.0",
+    "globals": "^15.14.0",
+    "husky": "^9.1.7",
+    "jest": "^30.0.3",
     "jest-environment-jsdom": "^30.0.2",
-    "ts-jest": "^29.4.0"
+    "prettier": "^3.4.2",
+    "ts-jest": "^29.4.0",
+    "typescript-eslint": "^8.19.1"
   },
   "dependencies": {
+    "chalk": "^5.3.0",
+    "commander": "^12.1.0",
     "dotenv": "^16.5.0",
-    "esbuild": "^0.25.5"
+    "figlet": "^1.8.0",
+    "inquirer": "^12.3.0",
+    "ora": "^8.1.1"
   }
 }