mikel-cli 0.33.1 → 0.34.0

package/README.md

@@ -3,7 +3,7 @@
 ![npm version](https://badgen.net/npm/v/mikel-cli?labelColor=1d2734&color=21bf81)
 ![license](https://badgen.net/github/license/jmjuanes/mikel?labelColor=1d2734&color=21bf81)
 
-A command-line interface for the [Mikel](https://github.com/jmjuanes/mikel) templating engine. This CLI tool allows you to render Mikel templates from the command line with support for data files, partials, helpers, and functions.
+A command-line interface for the [Mikel](https://github.com/jmjuanes/mikel) templating engine. This CLI tool allows you to render Mikel templates from the command line with support for data files, partials, helpers, functions, and plugins.
 
 ## Installation
 
@@ -31,6 +31,7 @@ $ mikel <template> [options]
 
 | Option | Short | Description |
 |--------|-------|-------------|
+| `--config <file>` | `-c` | Path to configuration file |
 | `--help` | `-h` | Display help information |
 | `--data <file>` | `-D` | Path to JSON data file |
 | `--output <file>` | `-o` | Output file path |
@@ -99,20 +100,6 @@ mikel template.html --partial 'components/**/*.html' --output dist/index.html
 mikel template.html --partial header.html --partial 'components/*.html' --output dist/index.html
 ```
 
-#### Complex Example
-
-A complete example combining all features:
-
-```bash
-mikel src/template.html \
-  --data src/data.json \
-  --partial 'src/partials/*.html' \
-  --partial 'src/components/**/*.html' \
-  --helper 'src/helpers/*.js' \
-  --function 'src/utils/*.js' \
-  --output dist/index.html
-```
-
 ### Glob Pattern Support
 
 The `--partial`, `--helper`, and `--function` options support glob patterns for loading multiple files at once:
@@ -126,6 +113,121 @@ The `--partial`, `--helper`, and `--function` options support glob patterns for
 
 **Note:** Glob patterns should be quoted to prevent shell expansion.
 
+## Configuration File
+
+For more complex use cases — multiple input files, output renaming, or plugins — you can use a configuration file instead of CLI arguments. Create a `mikel.config.js` file in your project root:
+
+```js
+export default {
+    input: "src/**/*.mustache",
+    output: {
+        dir: "dist/",
+        rename: {
+            "^src/(.+)\\.mustache$": "$1.html",
+        },
+    },
+    data: "./data/site.json",
+    plugins: [],
+};
+```
+
+Then run mikel pointing to the config file:
+
+```bash
+mikel --config mikel.config.js
+```
+
+CLI arguments take precedence over the configuration file when both are provided. However, when using a configuration file, `input` can be a glob or an array of globs — something not possible via CLI arguments alone.
+
+### Configuration Fields
+
+#### `input`
+
+The template file(s) to process. Accepts a string (file path or glob) or an array of strings:
+
+```js
+// single file
+input: "src/index.mustache"
+
+// array of files and globs
+input: ["src/index.mustache", "src/pages/**/*.mustache"]
+```
+
+#### `output`
+
+Where to write the rendered files. Accepts a string (directory path) or an object:
+
+```js
+// simple directory
+output: "dist/"
+
+// with rename rules
+output: {
+    dir: "dist/",
+    rename: {
+        "^src/(.+)\\.mustache$": "$1.html",
+    },
+}
+```
+
+The `rename` field works like Jest's `moduleNameMapper` — keys are regular expressions and values are replacement strings. The first matching pattern wins. If no pattern matches, the basename of the input file is used as the output filename.
+
+```js
+// src/docs/guide/index.mustache → dist/docs/guide/index.html
+rename: {
+    "^src/(.+)\\.mustache$": "$1.html",
+}
+```
+
+#### `data`
+
+Data to pass to the templates. Accepts a path to a JSON file or a plain object:
+
+```js
+// path to JSON file
+data: "./data/site.json"
+
+// inline object
+data: {
+    site: {
+        title: "My Site",
+    },
+}
+```
+
+#### `plugins`
+
+An array of Mikel plugins to load. See the [Plugins](#plugins) section for details.
+
+## Plugins
+
+Plugins extend Mikel's functionality by registering additional helpers, functions, or partials. They can be loaded both via the `--plugin` CLI flag and the `plugins` configuration field.
+
+### Loading Plugins via CLI
+
+Use the `--plugin` flag to load a plugin from a JavaScript module:
+
+```bash
+mikel template.html --plugin mikel-markdown --output dist/index.html
+```
+
+### Loading Plugins via Configuration
+
+Use the `plugins` field in your configuration file. Each entry can be a module name (string) or a tuple of `[moduleName, options]` when the plugin requires configuration:
+
+```js
+export default {
+    plugins: [
+        // plugin without options
+        "mikel-frontmatter",
+        // plugin with options
+        ["mikel-markdown", {
+            classNames: { ... },
+        }],
+    ],
+};
+```
+
 ## License
 
 Licensed under the [MIT License](../../LICENSE).

package/cli.js

@@ -0,0 +1,306 @@
+#!/usr/bin/env node
+
+import fs from "node:fs/promises";
+import { existsSync } from "node:fs";
+import path from "node:path";
+import { parseArgs } from "node:util";
+import mikel from "mikel";
+import { expandGlobPatterns, applyRename } from "./index.js";
+
+// load configuration file
+const loadConfiguration = async (configurationFile) => {
+    if (!configurationFile) {
+        return {};
+    }
+    const configurationPath = path.resolve(process.cwd(), configurationFile);
+    if (!existsSync(configurationPath)) {
+        throw new Error(`Configuration file '${configurationPath}' was not found.`);
+    }
+    // check the extension of the file
+    const configurationExtension = path.extname(configurationFile);
+    if (configurationExtension === ".js") {
+        return await import(configurationPath);
+    }
+    else if (configurationExtension === ".json") {
+        const content = await fs.readFile(configurationPath, "utf8");
+        return JSON.parse(content);
+    }
+    else {
+        throw new Error(`Unknown extension for configuration file '${configurationFile}'`);
+    }
+};
+
+// @description loading input files
+const loadInput = async (inputFiles) => {
+    if (!inputFiles || inputFiles?.length === 0) {
+        throw new Error(`No input templates provided.`);
+    }
+    // expand glob patterns
+    return expandGlobPatterns([inputFiles].flat());
+};
+
+// @description resolve output
+const resolveOutput = (inputFile, outputFile, outputConfig) => {
+    // 1. output file is provided via cli arguments
+    if (outputFile) {
+        return path.resolve(process.cwd(), outputFile);
+    }
+    // 2. output configuration is provided and it is a string
+    else if (outputConfig && typeof outputConfig === "string") {
+        return path.resolve(process.cwd(), path.join(outputConfig, inputFile));
+    }
+    // 3. output configuration is provided and it is an object
+    else if (outputConfig && typeof outputConfig === "object") {
+        const renamedOutputFile = applyRename(inputFile, outputConfig?.rename || {});
+        return path.resolve(process.cwd(), path.join(outputConfig?.dir || ".", renamedOutputFile));
+    }
+    // 4. other case???
+    throw new Error(`Unknown error resolving output for template '${inputFile}'`);
+};
+
+// @description load JSON data from the provided path
+const loadData = async (fileOrObject = null) => {
+    if (!fileOrObject) {
+        return {};
+    }
+    // 1. check for object containing data (from config.data)
+    if (typeof fileOrObject === "object") {
+        return fileOrObject;
+    }
+    // 2. build the full data file path and check if exists
+    const dataPath = path.resolve(process.cwd(), fileOrObject);
+    if (!existsSync(dataPath)) {
+        throw new Error(`Data file '${dataPath}' was not found.`);
+    }
+    // 3. read the file and parse it as JSON
+    try {
+        const content = await fs.readFile(dataPath, "utf8");
+        return JSON.parse(content);
+    } catch (error) {
+        if (error instanceof SyntaxError) {
+            throw new Error(`Invalid JSON in data file '${dataPath}': ${error.message}`);
+        }
+        throw new Error(`Failed to read data file '${dataPath}': ${error.message}`);
+    }
+};
+
+// @description load javascript modules
+const loadModules = async (patterns = [], callback) => {
+    const files = await expandGlobPatterns(patterns);
+    
+    for (let i = 0; i < files.length; i++) {
+        const file = files[i]; // path.resolve(process.cwd(), uniqueFiles[i]);
+        if (!existsSync(file)) {
+            throw new Error(`File '${file}' was not found.`);
+        }
+        
+        // Check if it's a file (not a directory)
+        const stats = await fs.stat(file);
+        if (!stats.isFile()) {
+            continue; // Skip directories
+        }
+        
+        // import the module
+        try {
+            await callback(file);
+        } catch (error) {
+            throw new Error(`Failed to load '${file}': ${error.message}`);
+        }
+    }
+};
+
+// print the help of the tool
+const printHelp = () => {
+    console.log("Usage: ");
+    console.log("  mikel --help");
+    console.log("  mikel <template> [...options]");
+    console.log("");
+    console.log("Options:");
+    console.log("  -h, --help              Prints the usage information");
+    console.log("  -P, --partial <file>    Register a partial (supports glob patterns, can be used multiple times)");
+    console.log("  -H, --helper <file>     Register a helper (supports glob patterns, can be used multiple times)");
+    console.log("  -F, --function <file>   Register a function (supports glob patterns, can be used multiple times)");
+    console.log("  -L, --plugin <file>     Load a plugin from node_modules (can be used multiple times)");
+    console.log("  -D, --data <file>       Path to the data file to use (JSON)");
+    console.log("  -o, --output <file>     Output file");
+    console.log("");
+    console.log("Examples:");
+    console.log("  mikel template.html --data data.json --output www/index.html");
+    console.log("  mikel template.html --data data.json --partial header.html --partial footer.html --output www/index.html");
+    console.log("  mikel template.html --helper helpers.js --function utils.js --output dist/index.html");
+    console.log("  mikel template.html --partial 'partials/*.html' --helper 'helpers/*.js' --output dist/index.html");
+    console.log("  mikel template.html --partial 'components/**/*.html' --output dist/index.html");
+    console.log("");
+    process.exit(0);
+};
+
+// @description main function
+const main = async (inputOption = "", options = {}) => {
+    // check to print help
+    if (options.help) {
+        return printHelp();
+    }
+
+    // load configuration file and inputs
+    const config = await loadConfiguration(options.config);
+    const inputs = await loadInput(inputOption || config.input || null);
+    const data = await loadData(options.data || config.data || null);
+    const mikelInstance = mikel.create({});
+
+    // if no input files were provided, throw an error and stop processing
+    if (!inputs || inputs?.length === 0) {
+        throw new Error(`No input templates found`);
+    }
+    // load plugins
+    const plugins = options.plugin || config.plugins || [];
+    for (let i = 0; i < plugins.length; i++) {
+        const pluginName = Array.isArray(plugins[i]) ? plugins[i][0] : plugins[i];
+        const pluginOptions = Array.isArray(plugins[i]) && plugins[i].length === 2 ? plugins[i][1] : null;
+        let pluginModule;
+        try {
+            // try to import the plugin from node_modules
+            pluginModule = (await import(pluginName))?.default;
+            if (typeof pluginModule !== "function") {
+                throw new Error(`Plugin '${pluginName}' does not export a valid plugin function.`);
+            }
+            mikelInstance.use(pluginModule(pluginOptions));
+        } catch (error) {
+            throw new Error(`Failed to load plugin '${pluginName}': ${error.message}`);
+        }
+    }
+
+    // load additional partials, helpers, and functions
+    await loadModules(options.partial, async (file) => {
+        try {
+            mikelInstance.addPartial(path.basename(file), await fs.readFile(file, "utf8"));
+        } catch (error) {
+            throw new Error(`Failed to read partial file '${file}': ${error.message}`);
+        }
+    });
+    await loadModules(options.helper, async (file) => {
+        const extension = path.extname(file);
+        if (extension !== ".js" && extension !== ".mjs") {
+            throw new Error(`Module '${file}' is not supported. Only ESM JavaScript (.js or .mjs) files are supported.`);
+        }
+        // import the module
+        const content = (await import(file)) || {};
+        if (typeof content === "object" && !!content) {
+            Object.keys(content).forEach(helperName => {
+                mikelInstance.addHelper(helperName, content[helperName]);
+            });
+        }
+    });
+    await loadModules(options.function, async (file) => {
+        const extension = path.extname(file);
+        if (extension !== ".js" && extension !== ".mjs") {
+            throw new Error(`Module '${file}' is not supported. Only ESM JavaScript (.js or .mjs) files are supported.`);
+        }
+        // import the module
+        const content = (await import(file)) || {};
+        if (typeof content === "object" && !!content) {
+            Object.keys(content).forEach(functionName => {
+                mikelInstance.addFunction(functionName, content[functionName]);
+            });
+        }
+    });
+    // process input files
+    for (let i = 0; i < inputs.length; i++) {
+        // const inputPath = path.resolve(process.cwd(), inputs[i]);
+        const inputPath = inputs[i]; // inputs contains absolute paths already
+        const relativeInputPath = path.relative(process.cwd(), inputPath);
+        if (!existsSync(inputPath)) {
+            throw new Error(`Template file '${inputPath}' was not found.`);
+        }
+        let template;
+        try {
+            template = await fs.readFile(inputPath, "utf8");
+        } catch (error) {
+            throw new Error(`Failed to read template file '${inputPath}': ${error.message}`);
+        }
+        // compile the template
+        let result;
+        try {
+            result = mikelInstance(template, data);
+        } catch (error) {
+            throw new Error(`Template compilation failed: ${error.message}`);
+        }
+        // check if output argument has been provided to write the result to a file
+        // this will also create any intermediary directory that does not exist
+        if (options.output || config.output) {
+            const outputPath = resolveOutput(relativeInputPath, options.output, config.output);
+            const outputDirectory = path.dirname(outputPath);
+            // make sure that any directory containing the output file exists
+            if (!existsSync(outputDirectory)) {
+                try {
+                    await fs.mkdir(outputDirectory, { recursive: true });
+                } catch (error) {
+                    throw new Error(`Failed to create output directory '${outputDirectory}': ${error.message}`);
+                }
+            }
+            try {
+                await fs.writeFile(outputPath, result, "utf8");
+                console.error(`✓ Saving '${inputPath}' -> '${outputPath}'`);
+            } catch (error) {
+                throw new Error(`Failed to write output file '${outputPath}': ${error.message}`);
+            }
+        }
+        // if no output file has been provided, print the result to console
+        else if (inputs.length === 1) {
+            process.stdout.write(result);
+        }
+        else {
+            throw new Error(`Unconsistent usage of input and output arguments.`);
+        }
+    }
+    // exit
+    process.exit(0);
+};
+
+// process arguments
+const { positionals, values } = parseArgs({
+    options: {
+        config: {
+            type: "string",
+            short: "c",
+        },
+        data: {
+            type: "string",
+            short: "D",
+        },
+        output: {
+            type: "string",
+            short: "o",
+        },
+        helper: {
+            type: "string",
+            short: "H",
+            multiple: true,
+        },
+        function: {
+            type: "string",
+            short: "F",
+            multiple: true,
+        },
+        partial: {
+            type: "string",
+            short: "P",
+            multiple: true,
+        },
+        plugin: {
+            type: "string",
+            short: "L",
+            multiple: true,
+        },
+        help: {
+            type: "boolean",
+            short: "h",
+        },
+    },
+    allowPositionals: true,
+});
+
+// run main script
+main(positionals[0], values).catch(error => {
+    console.error(`\n❌ Error: ${error.message}\n`);
+    process.exit(1);
+});

package/index.js

@@ -1,15 +1,10 @@
-#!/usr/bin/env node
-
 import fs from "node:fs/promises";
-import { existsSync } from "node:fs";
 import path from "node:path";
-import { parseArgs } from "node:util";
-import mikel from "mikel";
 
 // @description get the files that matches the provided patterns
 // this is a utility function to expand glob patterns to actual file paths.
 // it uses Node.js 24+ built-in fs.glob to handle glob patterns.
-const expandGlobPatterns = async (patterns = []) => {
+export const expandGlobPatterns = async (patterns = []) => {
     const files = [];
     for (let i = 0; i < patterns.length; i++) {
         const pattern = patterns[i];
@@ -33,233 +28,16 @@ const expandGlobPatterns = async (patterns = []) => {
     });
 };
 
-// @description load JSON data from the provided path
-const loadData = async (file = null) => {
-    if (!file) {
-        return {};
-    }
-    // build the full data file path and check if exists
-    const dataPath = path.resolve(process.cwd(), file);
-    if (!existsSync(dataPath)) {
-        throw new Error(`Data file '${dataPath}' was not found.`);
-    }
-    // read the file and parse it as JSON
-    try {
-        const content = await fs.readFile(dataPath, "utf8");
-        return JSON.parse(content);
-    } catch (error) {
-        if (error instanceof SyntaxError) {
-            throw new Error(`Invalid JSON in data file '${dataPath}': ${error.message}`);
-        }
-        throw new Error(`Failed to read data file '${dataPath}': ${error.message}`);
-    }
-};
-
-// @description load javascript modules
-const loadModules = async (patterns = [], callback) => {
-    const files = await expandGlobPatterns(patterns);
-    
-    for (let i = 0; i < files.length; i++) {
-        const file = files[i]; // path.resolve(process.cwd(), uniqueFiles[i]);
-        if (!existsSync(file)) {
-            throw new Error(`File '${file}' was not found.`);
-        }
-        
-        // Check if it's a file (not a directory)
-        const stats = await fs.stat(file);
-        if (!stats.isFile()) {
-            continue; // Skip directories
-        }
-        
-        // import the module
-        try {
-            await callback(file);
-        } catch (error) {
-            throw new Error(`Failed to load '${file}': ${error.message}`);
-        }
-    }
-};
-
-// print the help of the tool
-const printHelp = () => {
-    console.log("Usage: ");
-    console.log("  mikel --help");
-    console.log("  mikel <template> [...options]");
-    console.log("");
-    console.log("Options:");
-    console.log("  -h, --help              Prints the usage information");
-    console.log("  -P, --partial <file>    Register a partial (supports glob patterns, can be used multiple times)");
-    console.log("  -H, --helper <file>     Register a helper (supports glob patterns, can be used multiple times)");
-    console.log("  -F, --function <file>   Register a function (supports glob patterns, can be used multiple times)");
-    console.log("  -L, --plugin <file>     Load a plugin from node_modules (can be used multiple times)");
-    console.log("  -D, --data <file>       Path to the data file to use (JSON)");
-    console.log("  -o, --output <file>     Output file");
-    console.log("");
-    console.log("Examples:");
-    console.log("  mikel template.html --data data.json --output www/index.html");
-    console.log("  mikel template.html --data data.json --partial header.html --partial footer.html --output www/index.html");
-    console.log("  mikel template.html --helper helpers.js --function utils.js --output dist/index.html");
-    console.log("  mikel template.html --partial 'partials/*.html' --helper 'helpers/*.js' --output dist/index.html");
-    console.log("  mikel template.html --partial 'components/**/*.html' --output dist/index.html");
-    console.log("");
-    process.exit(0);
-};
-
-// @description main function
-const main = async (input = "", options = {}) => {
-    // check to print help
-    if (options.help) {
-        return printHelp();
-    }
-
-    // make sure that input file exists
-    if (!input) {
-        throw new Error(`No input template file provided.`);
-    }
-    const inputPath = path.resolve(process.cwd(), input);
-    if (!existsSync(inputPath)) {
-        throw new Error(`Template file '${inputPath}' was not found.`);
-    }
-    
-    let template;
-    try {
-        template = await fs.readFile(inputPath, "utf8");
-    } catch (error) {
-        throw new Error(`Failed to read template file '${inputPath}': ${error.message}`);
-    }
-
-    // initialize the template engine
-    const mikelInstance = mikel.create({});
-    const data = await loadData(options.data);
-
-    // load plugins
-    for (let i = 0; i < (options.plugin || []).length; i++) {
-        const pluginName = options.plugin[i];
-        let pluginModule;
-        try {
-            // try to import the plugin from node_modules
-            pluginModule = (await import(pluginName))?.default;
-            if (typeof pluginModule !== "function") {
-                throw new Error(`Plugin '${pluginName}' does not export a valid plugin function.`);
-            }
-            mikelInstance.use(pluginModule());
-        } catch (error) {
-            throw new Error(`Failed to load plugin '${pluginName}': ${error.message}`);
-        }
-    }
-
-    // load additional partials, helpers, and functions
-    await loadModules(options.partial, async (file) => {
-        try {
-            mikelInstance.addPartial(path.basename(file), await fs.readFile(file, "utf8"));
-        } catch (error) {
-            throw new Error(`Failed to read partial file '${file}': ${error.message}`);
-        }
-    });
-    await loadModules(options.helper, async (file) => {
-        const extension = path.extname(file);
-        if (extension !== ".js" && extension !== ".mjs") {
-            throw new Error(`Module '${file}' is not supported. Only ESM JavaScript (.js or .mjs) files are supported.`);
-        }
-        // import the module
-        const content = (await import(file)) || {};
-        if (typeof content === "object" && !!content) {
-            Object.keys(content).forEach(helperName => {
-                mikelInstance.addHelper(helperName, content[helperName]);
-            });
-        }
-    });
-    await loadModules(options.function, async (file) => {
-        const extension = path.extname(file);
-        if (extension !== ".js" && extension !== ".mjs") {
-            throw new Error(`Module '${file}' is not supported. Only ESM JavaScript (.js or .mjs) files are supported.`);
-        }
-        // import the module
-        const content = (await import(file)) || {};
-        if (typeof content === "object" && !!content) {
-            Object.keys(content).forEach(functionName => {
-                mikelInstance.addFunction(functionName, content[functionName]);
-            });
-        }
-    });
-
-    // compile the template
-    let result;
-    try {
-        result = mikelInstance(template, data || {});
-    } catch (error) {
-        throw new Error(`Template compilation failed: ${error.message}`);
-    }
-
-    // check if output argument has been provided to write the result to a file
-    // this will also create any intermediary directory that does not exist
-    if (options.output) {
-        const outputPath = path.resolve(process.cwd(), options.output);
-        const outputDirectory = path.dirname(outputPath);
-        // make sure that any directory containing the output file exists
-        if (!existsSync(outputDirectory)) {
-            try {
-                await fs.mkdir(outputDirectory, { recursive: true });
-            } catch (error) {
-                throw new Error(`Failed to create output directory '${outputDirectory}': ${error.message}`);
-            }
-        }
-        try {
-            await fs.writeFile(outputPath, result, "utf8");
-            console.error(`✓ Template rendered successfully to '${outputPath}'`);
-        } catch (error) {
-            throw new Error(`Failed to write output file '${outputPath}': ${error.message}`);
+// @description apply a rename to the provided file path based on a rename configuration
+// object
+export const applyRename = (filePath, rename = {}) => {
+    const patterns = Object.keys(rename);
+    for (let i = 0; i < patterns.length; i++) {
+        const regex = new RegExp(patterns[i]);
+        if (regex.test(filePath)) {
+            return filePath.replace(regex, rename[patterns[i]]);
         }
-        process.exit(0);
-    }
-    // if no output file has been provided, print the result to console
-    else {
-        process.stdout.write(result);
-        process.exit(0);
     }
+    // fallback: only returns the basename of the file
+    return path.basename(filePath);
 };
-
-// process arguments
-const { positionals, values } = parseArgs({
-    options: {
-        data: {
-            type: "string",
-            short: "D",
-        },
-        output: {
-            type: "string",
-            short: "o",
-        },
-        helper: {
-            type: "string",
-            short: "H",
-            multiple: true,
-        },
-        function: {
-            type: "string",
-            short: "F",
-            multiple: true,
-        },
-        partial: {
-            type: "string",
-            short: "P",
-            multiple: true,
-        },
-        plugin: {
-            type: "string",
-            short: "L",
-            multiple: true,
-        },
-        help: {
-            type: "boolean",
-            short: "h",
-        },
-    },
-    allowPositionals: true,
-});
-
-// run main script
-main(positionals[0], values).catch(error => {
-    console.error(`\n❌ Error: ${error.message}\n`);
-    process.exit(1);
-});

package/package.json

@@ -1,31 +1,39 @@
 {
     "name": "mikel-cli",
     "description": "The cli tool for mikel templating.",
-    "version": "0.33.1",
+    "version": "0.34.0",
     "type": "module",
     "license": "MIT",
     "author": {
         "name": "Josemi Juanes",
         "email": "hello@josemi.xyz"
     },
-    "repository": "https://github.com/jmjuanes/mikel",
+    "repository": {
+        "url": "https://github.com/jmjuanes/mikel",
+        "directory": "packages/mikel-cli"
+    },
     "bugs": "https://github.com/jmjuanes/mikel/issues",
     "engines": {
         "node": ">=24.0.0"
     },
+    "scripts": {
+        "test": "node test.js"
+    },
     "exports": {
         ".": "./index.js",
         "./index.js": "./index.js",
+        "./cli.js": "./cli.js",
         "./package.json": "./package.json"
     },
     "bin": {
-        "mikel": "index.js"
+        "mikel": "cli.js"
     },
     "peerDependencies": {
-        "mikel": "^0.33.1"
+        "mikel": "^0.34.0"
     },
     "files": [
         "README.md",
+        "cli.js",
         "index.js"
     ],
     "keywords": [